diff --git a/.gitignore b/.gitignore index b8bf43e..00c7e82 100644 --- a/.gitignore +++ b/.gitignore @@ -157,3 +157,6 @@ dmypy.json # End of https://www.toptal.com/developers/gitignore/api/python,vscode .project + +# OSX stuff +.DS_Store diff --git a/.isort.cfg b/.isort.cfg index 7f11e51..27971e2 100644 --- a/.isort.cfg +++ b/.isort.cfg @@ -1,2 +1,2 @@ [settings] -known_third_party = black,click,jinja2,pytest,setuptools,sql_to_code +known_third_party = antlr4,black,click,jinja2,pytest,setuptools,sql_to_code diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3a72155..ae99bce 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,12 @@ default_language_version: python: python3.7 +exclude: | + (?x)^( + sql_to_code/parsers/generated/PLpgSQLLexer.py| + sql_to_code/parsers/generated/PLpgSQLParser.py + )$ + repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v3.4.0 diff --git a/requirements/base.in b/requirements/base.in index 1ee70a2..17c5e21 100644 --- a/requirements/base.in +++ b/requirements/base.in @@ -1,3 +1,4 @@ click Jinja2 black +antlr4-python3-runtime diff --git a/requirements/base.txt b/requirements/base.txt index 10324cb..d28c48b 100644 --- a/requirements/base.txt +++ b/requirements/base.txt @@ -4,7 +4,8 @@ # # pip-compile --output-file=requirements/base.txt requirements/base.in # - +antlr4-python3-runtime==4.9.1 + # via -r requirements/base.in appdirs==1.4.4 # via black black==20.8b1 diff --git a/sql_to_code/generator.py b/sql_to_code/generator.py index 57212ed..240a6f0 100644 --- a/sql_to_code/generator.py +++ b/sql_to_code/generator.py @@ -27,9 +27,11 @@ def generate(template_name: str, context: Context) -> str: def generate_models(input_sql: str, generator: str, output_file: str) -> None: file_content: str = get_file_content(filename=input_sql) - raw_sql_commands: List[str] = parse_commands(content=file_content) + # raw_sql_commands: List[str] = parse_commands(content=file_content) context: Context = create_context(raw_sql_commands) + context: Context = parse_commands(content=file_content) + remmaper, output_template = GENERATOR_CONFIGS[generator] remmaper.remap(context) diff --git a/sql_to_code/parsers/generated/PLpgSQLLexer.g4 b/sql_to_code/parsers/generated/PLpgSQLLexer.g4 new file mode 100644 index 0000000..b399da3 --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLLexer.g4 @@ -0,0 +1,962 @@ +/* + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + +lexer grammar PLpgSQLLexer; + + /* + * Most keyword tokens are autogenerated using the list in the Keyword class, + * which comes directly from PostgreSQL source. + * Each word-token must also participate in a parser rule corresponding to + * its keyword's category. These are autogenerated using Keyword class. + * + * Manually added word-tokens must also be manually added to the + * tokens_nonkeyword parser rule. + */ + + /* + ================================================== + UNRESERVED_KEYWORD + ================================================== + */ + + ABORT: [aA] [bB] [oO] [rR] [tT]; // first identifier rule, sync with CustomSQLAntlrErrorStrategy + ABSOLUTE: [aA] [bB] [sS] [oO] [lL] [uU] [tT] [eE]; + ACCESS: [aA] [cC] [cC] [eE] [sS] [sS]; + ACTION: [aA] [cC] [tT] [iI] [oO] [nN]; + ADD: [aA] [dD] [dD]; + ADMIN: [aA] [dD] [mM] [iI] [nN]; + AFTER: [aA] [fF] [tT] [eE] [rR]; + AGGREGATE: [aA] [gG] [gG] [rR] [eE] [gG] [aA] [tT] [eE]; + ALSO: [aA] [lL] [sS] [oO]; + ALTER: [aA] [lL] [tT] [eE] [rR]; + ALWAYS: [aA] [lL] [wW] [aA] [yY] [sS]; + ASSERTION: [aA] [sS] [sS] [eE] [rR] [tT] [iI] [oO] [nN]; + ASSIGNMENT: [aA] [sS] [sS] [iI] [gG] [nN] [mM] [eE] [nN] [tT]; + AT: [aA] [tT]; + ATTACH: [aA] [tT] [tT] [aA] [cC] [hH]; + ATTRIBUTE: [aA] [tT] [tT] [rR] [iI] [bB] [uU] [tT] [eE]; + + BACKWARD: [bB] [aA] [cC] [kK] [wW] [aA] [rR] [dD]; + BEFORE: [bB] [eE] [fF] [oO] [rR] [eE]; + BEGIN: [bB] [eE] [gG] [iI] [nN]; + BY: [bB] [yY]; + + CACHE: [cC] [aA] [cC] [hH] [eE]; + CALL: [cC] [aA] [lL] [lL]; + CALLED: [cC] [aA] [lL] [lL] [eE] [dD]; + CASCADE: [cC] [aA] [sS] [cC] [aA] [dD] [eE]; + CASCADED: [cC] [aA] [sS] [cC] [aA] [dD] [eE] [dD]; + CATALOG: [cC] [aA] [tT] [aA] [lL] [oO] [gG]; + CHAIN: [cC] [hH] [aA] [iI] [nN]; + CHARACTERISTICS: [cC] [hH] [aA] [rR] [aA] [cC] [tT] [eE] [rR] [iI] [sS] [tT] [iI] [cC] [sS]; + CHECKPOINT: [cC] [hH] [eE] [cC] [kK] [pP] [oO] [iI] [nN] [tT]; + CLASS: [cC] [lL] [aA] [sS] [sS]; + CLOSE: [cC] [lL] [oO] [sS] [eE]; + CLUSTER: [cC] [lL] [uU] [sS] [tT] [eE] [rR]; + COLUMNS: [cC] [oO] [lL] [uU] [mM] [nN] [sS]; + COMMENT: [cC] [oO] [mM] [mM] [eE] [nN] [tT]; + COMMENTS: [cC] [oO] [mM] [mM] [eE] [nN] [tT] [sS]; + COMMIT: [cC] [oO] [mM] [mM] [iI] [tT]; + COMMITTED: [cC] [oO] [mM] [mM] [iI] [tT] [tT] [eE] [dD]; + CONFIGURATION: [cC] [oO] [nN] [fF] [iI] [gG] [uU] [rR] [aA] [tT] [iI] [oO] [nN]; + CONFLICT: [cC] [oO] [nN] [fF] [lL] [iI] [cC] [tT]; + CONNECTION: [cC] [oO] [nN] [nN] [eE] [cC] [tT] [iI] [oO] [nN]; + CONSTRAINTS: [cC] [oO] [nN] [sS] [tT] [rR] [aA] [iI] [nN] [tT] [sS]; + CONTENT: [cC] [oO] [nN] [tT] [eE] [nN] [tT]; + CONTINUE: [cC] [oO] [nN] [tT] [iI] [nN] [uU] [eE]; + CONVERSION: [cC] [oO] [nN] [vV] [eE] [rR] [sS] [iI] [oO] [nN]; + COPY: [cC] [oO] [pP] [yY]; + COST: [cC] [oO] [sS] [tT]; + CSV: [cC] [sS] [vV]; + CUBE: [cC] [uU] [bB] [eE]; + CURRENT: [cC] [uU] [rR] [rR] [eE] [nN] [tT]; + CURSOR: [cC] [uU] [rR] [sS] [oO] [rR]; + CYCLE: [cC] [yY] [cC] [lL] [eE]; + + DATA: [dD] [aA] [tT] [aA]; + DATABASE: [dD] [aA] [tT] [aA] [bB] [aA] [sS] [eE]; + DAY: [dD] [aA] [yY]; + DEALLOCATE: [dD] [eE] [aA] [lL] [lL] [oO] [cC] [aA] [tT] [eE]; + DECLARE: [dD] [eE] [cC] [lL] [aA] [rR] [eE]; + DEFAULTS: [dD] [eE] [fF] [aA] [uU] [lL] [tT] [sS]; + DEFERRED: [dD] [eE] [fF] [eE] [rR] [rR] [eE] [dD]; + DEFINER: [dD] [eE] [fF] [iI] [nN] [eE] [rR]; + DELETE: [dD] [eE] [lL] [eE] [tT] [eE]; + DELIMITER: [dD] [eE] [lL] [iI] [mM] [iI] [tT] [eE] [rR]; + DELIMITERS: [dD] [eE] [lL] [iI] [mM] [iI] [tT] [eE] [rR] [sS]; + DEPENDS: [dD] [eE] [pP] [eE] [nN] [dD] [sS]; + DETACH: [dD] [eE] [tT] [aA] [cC] [hH]; + DICTIONARY: [dD] [iI] [cC] [tT] [iI] [oO] [nN] [aA] [rR] [yY]; + DISABLE: [dD] [iI] [sS] [aA] [bB] [lL] [eE]; + DISCARD: [dD] [iI] [sS] [cC] [aA] [rR] [dD]; + DOCUMENT: [dD] [oO] [cC] [uU] [mM] [eE] [nN] [tT]; + DOMAIN: [dD] [oO] [mM] [aA] [iI] [nN]; + DOUBLE: [dD] [oO] [uU] [bB] [lL] [eE]; + DROP: [dD] [rR] [oO] [pP]; + + EACH: [eE] [aA] [cC] [hH]; + ENABLE: [eE] [nN] [aA] [bB] [lL] [eE]; + ENCODING: [eE] [nN] [cC] [oO] [dD] [iI] [nN] [gG]; + ENCRYPTED: [eE] [nN] [cC] [rR] [yY] [pP] [tT] [eE] [dD]; + ENUM: [eE] [nN] [uU] [mM]; + ESCAPE: [eE] [sS] [cC] [aA] [pP] [eE]; + EVENT: [eE] [vV] [eE] [nN] [tT]; + EXCLUDE: [eE] [xX] [cC] [lL] [uU] [dD] [eE]; + EXCLUDING: [eE] [xX] [cC] [lL] [uU] [dD] [iI] [nN] [gG]; + EXCLUSIVE: [eE] [xX] [cC] [lL] [uU] [sS] [iI] [vV] [eE]; + EXECUTE: [eE] [xX] [eE] [cC] [uU] [tT] [eE]; + EXPLAIN: [eE] [xX] [pP] [lL] [aA] [iI] [nN]; + EXTENSION: [eE] [xX] [tT] [eE] [nN] [sS] [iI] [oO] [nN]; + EXTERNAL: [eE] [xX] [tT] [eE] [rR] [nN] [aA] [lL]; + + FAMILY: [fF] [aA] [mM] [iI] [lL] [yY]; + FILTER: [fF] [iI] [lL] [tT] [eE] [rR]; + FIRST: [fF] [iI] [rR] [sS] [tT]; + FOLLOWING: [fF] [oO] [lL] [lL] [oO] [wW] [iI] [nN] [gG]; + FORCE: [fF] [oO] [rR] [cC] [eE]; + FORWARD: [fF] [oO] [rR] [wW] [aA] [rR] [dD]; + FUNCTION: [fF] [uU] [nN] [cC] [tT] [iI] [oO] [nN]; + FUNCTIONS: [fF] [uU] [nN] [cC] [tT] [iI] [oO] [nN] [sS]; + + GENERATED: [gG] [eE] [nN] [eE] [rR] [aA] [tT] [eE] [dD]; + GLOBAL: [gG] [lL] [oO] [bB] [aA] [lL]; + GRANTED: [gG] [rR] [aA] [nN] [tT] [eE] [dD]; + GROUPS: [gG] [rR] [oO] [uU] [pP] [sS]; + + HANDLER: [hH] [aA] [nN] [dD] [lL] [eE] [rR]; + HEADER: [hH] [eE] [aA] [dD] [eE] [rR]; + HOLD: [hH] [oO] [lL] [dD]; + HOUR: [hH] [oO] [uU] [rR]; + + IDENTITY: [iI] [dD] [eE] [nN] [tT] [iI] [tT] [yY]; + IF: [iI] [fF]; + IMMEDIATE: [iI] [mM] [mM] [eE] [dD] [iI] [aA] [tT] [eE]; + IMMUTABLE: [iI] [mM] [mM] [uU] [tT] [aA] [bB] [lL] [eE]; + IMPLICIT: [iI] [mM] [pP] [lL] [iI] [cC] [iI] [tT]; + IMPORT: [iI] [mM] [pP] [oO] [rR] [tT]; + INCLUDE: [iI] [nN] [cC] [lL] [uU] [dD] [eE]; + INCLUDING: [iI] [nN] [cC] [lL] [uU] [dD] [iI] [nN] [gG]; + INCREMENT: [iI] [nN] [cC] [rR] [eE] [mM] [eE] [nN] [tT]; + INDEX: [iI] [nN] [dD] [eE] [xX]; + INDEXES: [iI] [nN] [dD] [eE] [xX] [eE] [sS]; + INHERIT: [iI] [nN] [hH] [eE] [rR] [iI] [tT]; + INHERITS: [iI] [nN] [hH] [eE] [rR] [iI] [tT] [sS]; + INLINE: [iI] [nN] [lL] [iI] [nN] [eE]; + INPUT: [iI] [nN] [pP] [uU] [tT]; + INSENSITIVE: [iI] [nN] [sS] [eE] [nN] [sS] [iI] [tT] [iI] [vV] [eE]; + INSERT: [iI] [nN] [sS] [eE] [rR] [tT]; + INSTEAD: [iI] [nN] [sS] [tT] [eE] [aA] [dD]; + INVOKER: [iI] [nN] [vV] [oO] [kK] [eE] [rR]; + ISOLATION: [iI] [sS] [oO] [lL] [aA] [tT] [iI] [oO] [nN]; + + KEY: [kK] [eE] [yY]; + + LABEL: [lL] [aA] [bB] [eE] [lL]; + LANGUAGE: [lL] [aA] [nN] [gG] [uU] [aA] [gG] [eE]; + LARGE: [lL] [aA] [rR] [gG] [eE]; + LAST: [lL] [aA] [sS] [tT]; + LEAKPROOF: [lL] [eE] [aA] [kK] [pP] [rR] [oO] [oO] [fF]; + LEVEL: [lL] [eE] [vV] [eE] [lL]; + LISTEN: [lL] [iI] [sS] [tT] [eE] [nN]; + LOAD: [lL] [oO] [aA] [dD]; + LOCAL: [lL] [oO] [cC] [aA] [lL]; + LOCATION: [lL] [oO] [cC] [aA] [tT] [iI] [oO] [nN]; + LOCK: [lL] [oO] [cC] [kK]; + LOCKED: [lL] [oO] [cC] [kK] [eE] [dD]; + LOGGED: [lL] [oO] [gG] [gG] [eE] [dD]; + + MAPPING: [mM] [aA] [pP] [pP] [iI] [nN] [gG]; + MATCH: [mM] [aA] [tT] [cC] [hH]; + MATERIALIZED: [mM] [aA] [tT] [eE] [rR] [iI] [aA] [lL] [iI] [zZ] [eE] [dD]; + MAXVALUE: [mM] [aA] [xX] [vV] [aA] [lL] [uU] [eE]; + METHOD: [mM] [eE] [tT] [hH] [oO] [dD]; + MINUTE: [mM] [iI] [nN] [uU] [tT] [eE]; + MINVALUE: [mM] [iI] [nN] [vV] [aA] [lL] [uU] [eE]; + MODE: [mM] [oO] [dD] [eE]; + MONTH: [mM] [oO] [nN] [tT] [hH]; + MOVE: [mM] [oO] [vV] [eE]; + + NAME: [nN] [aA] [mM] [eE]; + NAMES: [nN] [aA] [mM] [eE] [sS]; + NEW: [nN] [eE] [wW]; + NEXT: [nN] [eE] [xX] [tT]; + NO: [nN] [oO]; + NOTHING: [nN] [oO] [tT] [hH] [iI] [nN] [gG]; + NOTIFY: [nN] [oO] [tT] [iI] [fF] [yY]; + NOWAIT: [nN] [oO] [wW] [aA] [iI] [tT]; + NULLS: [nN] [uU] [lL] [lL] [sS]; + + OBJECT: [oO] [bB] [jJ] [eE] [cC] [tT]; + OF: [oO] [fF]; + OFF: [oO] [fF] [fF]; + OIDS: [oO] [iI] [dD] [sS]; + OLD: [oO] [lL] [dD]; + OPERATOR: [oO] [pP] [eE] [rR] [aA] [tT] [oO] [rR]; + OPTION: [oO] [pP] [tT] [iI] [oO] [nN]; + OPTIONS: [oO] [pP] [tT] [iI] [oO] [nN] [sS]; + ORDINALITY: [oO] [rR] [dD] [iI] [nN] [aA] [lL] [iI] [tT] [yY]; + OTHERS: [oO] [tT] [hH] [eE] [rR] [sS]; + OVER: [oO] [vV] [eE] [rR]; + OVERRIDING: [oO] [vV] [eE] [rR] [rR] [iI] [dD] [iI] [nN] [gG]; + OWNED: [oO] [wW] [nN] [eE] [dD]; + OWNER: [oO] [wW] [nN] [eE] [rR]; + + PARALLEL: [pP] [aA] [rR] [aA] [lL] [lL] [eE] [lL]; + PARSER: [pP] [aA] [rR] [sS] [eE] [rR]; + PARTIAL: [pP] [aA] [rR] [tT] [iI] [aA] [lL]; + PARTITION: [pP] [aA] [rR] [tT] [iI] [tT] [iI] [oO] [nN]; + PASSING: [pP] [aA] [sS] [sS] [iI] [nN] [gG]; + PASSWORD: [pP] [aA] [sS] [sS] [wW] [oO] [rR] [dD]; + PLANS: [pP] [lL] [aA] [nN] [sS]; + POLICY: [pP] [oO] [lL] [iI] [cC] [yY]; + PRECEDING: [pP] [rR] [eE] [cC] [eE] [dD] [iI] [nN] [gG]; + PREPARE: [pP] [rR] [eE] [pP] [aA] [rR] [eE]; + PREPARED: [pP] [rR] [eE] [pP] [aA] [rR] [eE] [dD]; + PRESERVE: [pP] [rR] [eE] [sS] [eE] [rR] [vV] [eE]; + PRIOR: [pP] [rR] [iI] [oO] [rR]; + PRIVILEGES: [pP] [rR] [iI] [vV] [iI] [lL] [eE] [gG] [eE] [sS]; + PROCEDURAL: [pP] [rR] [oO] [cC] [eE] [dD] [uU] [rR] [aA] [lL]; + PROCEDURE: [pP] [rR] [oO] [cC] [eE] [dD] [uU] [rR] [eE]; + PROCEDURES: [pP] [rR] [oO] [cC] [eE] [dD] [uU] [rR] [eE] [sS]; + PROGRAM: [pP] [rR] [oO] [gG] [rR] [aA] [mM]; + PUBLICATION: [pP] [uU] [bB] [lL] [iI] [cC] [aA] [tT] [iI] [oO] [nN]; + + QUOTE: [qQ] [uU] [oO] [tT] [eE]; + + RANGE: [rR] [aA] [nN] [gG] [eE]; + READ: [rR] [eE] [aA] [dD]; + REASSIGN: [rR] [eE] [aA] [sS] [sS] [iI] [gG] [nN]; + RECHECK: [rR] [eE] [cC] [hH] [eE] [cC] [kK]; + RECURSIVE: [rR] [eE] [cC] [uU] [rR] [sS] [iI] [vV] [eE]; + REF: [rR] [eE] [fF]; + REFERENCING: [rR] [eE] [fF] [eE] [rR] [eE] [nN] [cC] [iI] [nN] [gG]; + REFRESH: [rR] [eE] [fF] [rR] [eE] [sS] [hH]; + REINDEX: [rR] [eE] [iI] [nN] [dD] [eE] [xX]; + RELATIVE: [rR] [eE] [lL] [aA] [tT] [iI] [vV] [eE]; + RELEASE: [rR] [eE] [lL] [eE] [aA] [sS] [eE]; + RENAME: [rR] [eE] [nN] [aA] [mM] [eE]; + REPEATABLE: [rR] [eE] [pP] [eE] [aA] [tT] [aA] [bB] [lL] [eE]; + REPLACE: [rR] [eE] [pP] [lL] [aA] [cC] [eE]; + REPLICA: [rR] [eE] [pP] [lL] [iI] [cC] [aA]; + RESET: [rR] [eE] [sS] [eE] [tT]; + RESTART: [rR] [eE] [sS] [tT] [aA] [rR] [tT]; + RESTRICT: [rR] [eE] [sS] [tT] [rR] [iI] [cC] [tT]; + RETURNS: [rR] [eE] [tT] [uU] [rR] [nN] [sS]; + REVOKE: [rR] [eE] [vV] [oO] [kK] [eE]; + ROLE: [rR] [oO] [lL] [eE]; + ROLLBACK: [rR] [oO] [lL] [lL] [bB] [aA] [cC] [kK]; + ROLLUP: [rR] [oO] [lL] [lL] [uU] [pP]; + ROUTINE: [rR] [oO] [uU] [tT] [iI] [nN] [eE]; + ROUTINES: [rR] [oO] [uU] [tT] [iI] [nN] [eE] [sS]; + ROWS: [rR] [oO] [wW] [sS]; + RULE: [rR] [uU] [lL] [eE]; + + SAVEPOINT: [sS] [aA] [vV] [eE] [pP] [oO] [iI] [nN] [tT]; + SCHEMA: [sS] [cC] [hH] [eE] [mM] [aA]; + SCHEMAS: [sS] [cC] [hH] [eE] [mM] [aA] [sS]; + SCROLL: [sS] [cC] [rR] [oO] [lL] [lL]; + SEARCH: [sS] [eE] [aA] [rR] [cC] [hH]; + SECOND: [sS] [eE] [cC] [oO] [nN] [dD]; + SECURITY: [sS] [eE] [cC] [uU] [rR] [iI] [tT] [yY]; + SEQUENCE: [sS] [eE] [qQ] [uU] [eE] [nN] [cC] [eE]; + SEQUENCES: [sS] [eE] [qQ] [uU] [eE] [nN] [cC] [eE] [sS]; + SERIALIZABLE: [sS] [eE] [rR] [iI] [aA] [lL] [iI] [zZ] [aA] [bB] [lL] [eE]; + SERVER: [sS] [eE] [rR] [vV] [eE] [rR]; + SESSION: [sS] [eE] [sS] [sS] [iI] [oO] [nN]; + SET: [sS] [eE] [tT]; + SETS: [sS] [eE] [tT] [sS]; + SHARE: [sS] [hH] [aA] [rR] [eE]; + SHOW: [sS] [hH] [oO] [wW]; + SIMPLE: [sS] [iI] [mM] [pP] [lL] [eE]; + // SKIP is reserved by ANTLR + SKIP_: [sS] [kK] [iI] [pP]; + SNAPSHOT: [sS] [nN] [aA] [pP] [sS] [hH] [oO] [tT]; + SQL: [sS] [qQ] [lL]; + STABLE: [sS] [tT] [aA] [bB] [lL] [eE]; + STANDALONE: [sS] [tT] [aA] [nN] [dD] [aA] [lL] [oO] [nN] [eE]; + START: [sS] [tT] [aA] [rR] [tT]; + STATEMENT: [sS] [tT] [aA] [tT] [eE] [mM] [eE] [nN] [tT]; + STATISTICS: [sS] [tT] [aA] [tT] [iI] [sS] [tT] [iI] [cC] [sS]; + STDIN: [sS] [tT] [dD] [iI] [nN]; + STDOUT: [sS] [tT] [dD] [oO] [uU] [tT]; + STORAGE: [sS] [tT] [oO] [rR] [aA] [gG] [eE]; + STORED: [sS] [tT] [oO] [rR] [eE] [dD]; + STRICT: [sS] [tT] [rR] [iI] [cC] [tT]; + STRIP: [sS] [tT] [rR] [iI] [pP]; + SUBSCRIPTION: [sS] [uU] [bB] [sS] [cC] [rR] [iI] [pP] [tT] [iI] [oO] [nN]; + SUPPORT: [sS] [uU] [pP] [pP] [oO] [rR] [tT]; + SYSID: [sS] [yY] [sS] [iI] [dD]; + SYSTEM: [sS] [yY] [sS] [tT] [eE] [mM]; + + TABLES: [tT] [aA] [bB] [lL] [eE] [sS]; + TABLESPACE: [tT] [aA] [bB] [lL] [eE] [sS] [pP] [aA] [cC] [eE]; + TEMP: [tT] [eE] [mM] [pP]; + TEMPLATE: [tT] [eE] [mM] [pP] [lL] [aA] [tT] [eE]; + TEMPORARY: [tT] [eE] [mM] [pP] [oO] [rR] [aA] [rR] [yY]; + TEXT: [tT] [eE] [xX] [tT]; + TIES: [tT] [iI] [eE] [sS]; + TRANSACTION: [tT] [rR] [aA] [nN] [sS] [aA] [cC] [tT] [iI] [oO] [nN]; + TRANSFORM: [tT] [rR] [aA] [nN] [sS] [fF] [oO] [rR] [mM]; + TRIGGER: [tT] [rR] [iI] [gG] [gG] [eE] [rR]; + TRUNCATE: [tT] [rR] [uU] [nN] [cC] [aA] [tT] [eE]; + TRUSTED: [tT] [rR] [uU] [sS] [tT] [eE] [dD]; + TYPE: [tT] [yY] [pP] [eE]; + TYPES: [tT] [yY] [pP] [eE] [sS]; + + UNBOUNDED: [uU] [nN] [bB] [oO] [uU] [nN] [dD] [eE] [dD]; + UNCOMMITTED: [uU] [nN] [cC] [oO] [mM] [mM] [iI] [tT] [tT] [eE] [dD]; + UNENCRYPTED: [uU] [nN] [eE] [nN] [cC] [rR] [yY] [pP] [tT] [eE] [dD]; + UNKNOWN: [uU] [nN] [kK] [nN] [oO] [wW] [nN]; + UNLISTEN: [uU] [nN] [lL] [iI] [sS] [tT] [eE] [nN]; + UNLOGGED: [uU] [nN] [lL] [oO] [gG] [gG] [eE] [dD]; + UNTIL: [uU] [nN] [tT] [iI] [lL]; + UPDATE: [uU] [pP] [dD] [aA] [tT] [eE]; + + VACUUM: [vV] [aA] [cC] [uU] [uU] [mM]; + VALID: [vV] [aA] [lL] [iI] [dD]; + VALIDATE: [vV] [aA] [lL] [iI] [dD] [aA] [tT] [eE]; + VALIDATOR: [vV] [aA] [lL] [iI] [dD] [aA] [tT] [oO] [rR]; + VALUE: [vV] [aA] [lL] [uU] [eE]; + VARYING: [vV] [aA] [rR] [yY] [iI] [nN] [gG]; + VERSION: [vV] [eE] [rR] [sS] [iI] [oO] [nN]; + VIEW: [vV] [iI] [eE] [wW]; + VIEWS: [vV] [iI] [eE] [wW] [sS]; + VOLATILE: [vV] [oO] [lL] [aA] [tT] [iI] [lL] [eE]; + + WHITESPACE: [wW] [hH] [iI] [tT] [eE] [sS] [pP] [aA] [cC] [eE]; + WITHIN: [wW] [iI] [tT] [hH] [iI] [nN]; + WITHOUT: [wW] [iI] [tT] [hH] [oO] [uU] [tT]; + WORK: [wW] [oO] [rR] [kK]; + WRAPPER: [wW] [rR] [aA] [pP] [pP] [eE] [rR]; + WRITE: [wW] [rR] [iI] [tT] [eE]; + + XML: [xX] [mM] [lL]; + + YEAR: [yY] [eE] [aA] [rR]; + YES: [yY] [eE] [sS]; + + ZONE: [zZ] [oO] [nN] [eE]; + + /* + ================================================== + COL_NAME_KEYWORD + ================================================== + */ + + BETWEEN: [bB] [eE] [tT] [wW] [eE] [eE] [nN]; + BIGINT: [bB] [iI] [gG] [iI] [nN] [tT]; + BIT: [bB] [iI] [tT]; + BOOLEAN: [bB] [oO] [oO] [lL] [eE] [aA] [nN]; + + CHAR: [cC] [hH] [aA] [rR]; + CHARACTER: [cC] [hH] [aA] [rR] [aA] [cC] [tT] [eE] [rR]; + COALESCE: [cC] [oO] [aA] [lL] [eE] [sS] [cC] [eE]; + + DEC: [dD] [eE] [cC]; + DECIMAL: [dD] [eE] [cC] [iI] [mM] [aA] [lL]; + + EXISTS: [eE] [xX] [iI] [sS] [tT] [sS]; + EXTRACT: [eE] [xX] [tT] [rR] [aA] [cC] [tT]; + + FLOAT: [fF] [lL] [oO] [aA] [tT]; + + GREATEST: [gG] [rR] [eE] [aA] [tT] [eE] [sS] [tT]; + GROUPING: [gG] [rR] [oO] [uU] [pP] [iI] [nN] [gG]; + + INOUT: [iI] [nN] [oO] [uU] [tT]; + INT: [iI] [nN] [tT]; + INTEGER: [iI] [nN] [tT] [eE] [gG] [eE] [rR]; + INTERVAL: [iI] [nN] [tT] [eE] [rR] [vV] [aA] [lL]; + + LEAST: [lL] [eE] [aA] [sS] [tT]; + + NATIONAL: [nN] [aA] [tT] [iI] [oO] [nN] [aA] [lL]; + NCHAR: [nN] [cC] [hH] [aA] [rR]; + NONE: [nN] [oO] [nN] [eE]; + NULLIF: [nN] [uU] [lL] [lL] [iI] [fF]; + NUMERIC: [nN] [uU] [mM] [eE] [rR] [iI] [cC]; + + OUT: [oO] [uU] [tT]; + OVERLAY: [oO] [vV] [eE] [rR] [lL] [aA] [yY]; + + POSITION: [pP] [oO] [sS] [iI] [tT] [iI] [oO] [nN]; + PRECISION: [pP] [rR] [eE] [cC] [iI] [sS] [iI] [oO] [nN]; + + REAL: [rR] [eE] [aA] [lL]; + ROW: [rR] [oO] [wW]; + + SETOF: [sS] [eE] [tT] [oO] [fF]; + SMALLINT: [sS] [mM] [aA] [lL] [lL] [iI] [nN] [tT]; + SUBSTRING: [sS] [uU] [bB] [sS] [tT] [rR] [iI] [nN] [gG]; + + TIME: [tT] [iI] [mM] [eE]; + TIMESTAMP: [tT] [iI] [mM] [eE] [sS] [tT] [aA] [mM] [pP]; + TREAT: [tT] [rR] [eE] [aA] [tT]; + TRIM: [tT] [rR] [iI] [mM]; + + VALUES: [vV] [aA] [lL] [uU] [eE] [sS]; + VARCHAR: [vV] [aA] [rR] [cC] [hH] [aA] [rR]; + + XMLATTRIBUTES: [xX] [mM] [lL] [aA] [tT] [tT] [rR] [iI] [bB] [uU] [tT] [eE] [sS]; + XMLCONCAT: [xX] [mM] [lL] [cC] [oO] [nN] [cC] [aA] [tT]; + XMLELEMENT: [xX] [mM] [lL] [eE] [lL] [eE] [mM] [eE] [nN] [tT]; + XMLEXISTS: [xX] [mM] [lL] [eE] [xX] [iI] [sS] [tT] [sS]; + XMLFOREST: [xX] [mM] [lL] [fF] [oO] [rR] [eE] [sS] [tT]; + XMLNAMESPACES: [xX] [mM] [lL] [nN] [aA] [mM] [eE] [sS] [pP] [aA] [cC] [eE] [sS]; + XMLPARSE: [xX] [mM] [lL] [pP] [aA] [rR] [sS] [eE]; + XMLPI: [xX] [mM] [lL] [pP] [iI]; + XMLROOT: [xX] [mM] [lL] [rR] [oO] [oO] [tT]; + XMLSERIALIZE: [xX] [mM] [lL] [sS] [eE] [rR] [iI] [aA] [lL] [iI] [zZ] [eE]; + XMLTABLE: [xX] [mM] [lL] [tT] [aA] [bB] [lL] [eE]; + + /* + ================================================== + TYPE_FUNC_NAME_KEYWORD + ================================================== + */ + + AUTHORIZATION: [aA] [uU] [tT] [hH] [oO] [rR] [iI] [zZ] [aA] [tT] [iI] [oO] [nN]; + + BINARY: [bB] [iI] [nN] [aA] [rR] [yY]; + + COLLATION: [cC] [oO] [lL] [lL] [aA] [tT] [iI] [oO] [nN]; + CONCURRENTLY: [cC] [oO] [nN] [cC] [uU] [rR] [rR] [eE] [nN] [tT] [lL] [yY]; + CROSS: [cC] [rR] [oO] [sS] [sS]; + CURRENT_SCHEMA: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [sS] [cC] [hH] [eE] [mM] [aA]; + + FREEZE: [fF] [rR] [eE] [eE] [zZ] [eE]; + FULL: [fF] [uU] [lL] [lL]; + + ILIKE: [iI] [lL] [iI] [kK] [eE]; + INNER: [iI] [nN] [nN] [eE] [rR]; + IS: [iI] [sS]; + ISNULL: [iI] [sS] [nN] [uU] [lL] [lL]; + + JOIN: [jJ] [oO] [iI] [nN]; + + LEFT: [lL] [eE] [fF] [tT]; + LIKE: [lL] [iI] [kK] [eE]; + + NATURAL: [nN] [aA] [tT] [uU] [rR] [aA] [lL]; + NOTNULL: [nN] [oO] [tT] [nN] [uU] [lL] [lL]; + + OUTER: [oO] [uU] [tT] [eE] [rR]; + OVERLAPS: [oO] [vV] [eE] [rR] [lL] [aA] [pP] [sS]; + + RIGHT: [rR] [iI] [gG] [hH] [tT]; + + SIMILAR: [sS] [iI] [mM] [iI] [lL] [aA] [rR]; + + TABLESAMPLE: [tT] [aA] [bB] [lL] [eE] [sS] [aA] [mM] [pP] [lL] [eE]; + + VERBOSE: [vV] [eE] [rR] [bB] [oO] [sS] [eE]; + + /* + ================================================== + RESERVED_KEYWORD + ================================================== + */ + + ALL: [aA] [lL] [lL]; // first RESERVED_KEYWORD, sync with AntlrUtils.normalizeWhitespaceUnquoted + ANALYSE: [aA] [nN] [aA] [lL] [yY] [sS] [eE]; + ANALYZE: [aA] [nN] [aA] [lL] [yY] [zZ] [eE]; + AND: [aA] [nN] [dD]; + ANY: [aA] [nN] [yY]; + ARRAY: [aA] [rR] [rR] [aA] [yY]; + AS: [aA] [sS]; + ASC: [aA] [sS] [cC]; + ASYMMETRIC: [aA] [sS] [yY] [mM] [mM] [eE] [tT] [rR] [iI] [cC]; + + BOTH: [bB] [oO] [tT] [hH]; + + CASE: [cC] [aA] [sS] [eE]; + CAST: [cC] [aA] [sS] [tT]; + CHECK: [cC] [hH] [eE] [cC] [kK]; + COLLATE: [cC] [oO] [lL] [lL] [aA] [tT] [eE]; + COLUMN: [cC] [oO] [lL] [uU] [mM] [nN]; + CONSTRAINT: [cC] [oO] [nN] [sS] [tT] [rR] [aA] [iI] [nN] [tT]; + CREATE: [cC] [rR] [eE] [aA] [tT] [eE]; + CURRENT_CATALOG: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [cC] [aA] [tT] [aA] [lL] [oO] [gG]; + CURRENT_DATE: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [dD] [aA] [tT] [eE]; + CURRENT_ROLE: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [rR] [oO] [lL] [eE]; + CURRENT_TIME: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [tT] [iI] [mM] [eE]; + CURRENT_TIMESTAMP: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [tT] [iI] [mM] [eE] [sS] [tT] [aA] [mM] [pP]; + CURRENT_USER: [cC] [uU] [rR] [rR] [eE] [nN] [tT] UNDERLINE [uU] [sS] [eE] [rR]; + + DEFAULT: [dD] [eE] [fF] [aA] [uU] [lL] [tT]; + DEFERRABLE: [dD] [eE] [fF] [eE] [rR] [rR] [aA] [bB] [lL] [eE]; + DESC: [dD] [eE] [sS] [cC]; + DISTINCT: [dD] [iI] [sS] [tT] [iI] [nN] [cC] [tT]; + DO: [dD] [oO]; + + ELSE: [eE] [lL] [sS] [eE]; + END: [eE] [nN] [dD]; + EXCEPT: [eE] [xX] [cC] [eE] [pP] [tT]; + + FALSE: [fF] [aA] [lL] [sS] [eE]; + FETCH: [fF] [eE] [tT] [cC] [hH]; + FOR: [fF] [oO] [rR]; + FOREIGN: [fF] [oO] [rR] [eE] [iI] [gG] [nN]; + FROM: [fF] [rR] [oO] [mM]; + + GRANT: [gG] [rR] [aA] [nN] [tT]; + GROUP: [gG] [rR] [oO] [uU] [pP]; + + HAVING: [hH] [aA] [vV] [iI] [nN] [gG]; + + IN: [iI] [nN]; + INITIALLY: [iI] [nN] [iI] [tT] [iI] [aA] [lL] [lL] [yY]; + INTERSECT: [iI] [nN] [tT] [eE] [rR] [sS] [eE] [cC] [tT]; + INTO: [iI] [nN] [tT] [oO]; + + LATERAL: [lL] [aA] [tT] [eE] [rR] [aA] [lL]; + LEADING: [lL] [eE] [aA] [dD] [iI] [nN] [gG]; + LIMIT: [lL] [iI] [mM] [iI] [tT]; + LOCALTIME: [lL] [oO] [cC] [aA] [lL] [tT] [iI] [mM] [eE]; + LOCALTIMESTAMP: [lL] [oO] [cC] [aA] [lL] [tT] [iI] [mM] [eE] [sS] [tT] [aA] [mM] [pP]; + + NOT: [nN] [oO] [tT]; + NULL: [nN] [uU] [lL] [lL]; + + OFFSET: [oO] [fF] [fF] [sS] [eE] [tT]; + ON: [oO] [nN]; + ONLY: [oO] [nN] [lL] [yY]; + OR: [oO] [rR]; + ORDER: [oO] [rR] [dD] [eE] [rR]; + + PLACING: [pP] [lL] [aA] [cC] [iI] [nN] [gG]; + PRIMARY: [pP] [rR] [iI] [mM] [aA] [rR] [yY]; + + REFERENCES: [rR] [eE] [fF] [eE] [rR] [eE] [nN] [cC] [eE] [sS]; + RETURNING: [rR] [eE] [tT] [uU] [rR] [nN] [iI] [nN] [gG]; + + SELECT: [sS] [eE] [lL] [eE] [cC] [tT]; + SESSION_USER: [sS] [eE] [sS] [sS] [iI] [oO] [nN] UNDERLINE [uU] [sS] [eE] [rR]; + SOME: [sS] [oO] [mM] [eE]; + SYMMETRIC: [sS] [yY] [mM] [mM] [eE] [tT] [rR] [iI] [cC]; + + TABLE: [tT] [aA] [bB] [lL] [eE]; + THEN: [tT] [hH] [eE] [nN]; + TO: [tT] [oO]; + TRAILING: [tT] [rR] [aA] [iI] [lL] [iI] [nN] [gG]; + TRUE: [tT] [rR] [uU] [eE]; + + UNION: [uU] [nN] [iI] [oO] [nN]; + UNIQUE: [uU] [nN] [iI] [qQ] [uU] [eE]; + USER: [uU] [sS] [eE] [rR]; + USING: [uU] [sS] [iI] [nN] [gG]; + + VARIADIC: [vV] [aA] [rR] [iI] [aA] [dD] [iI] [cC]; + + WHEN: [wW] [hH] [eE] [nN]; + WHERE: [wW] [hH] [eE] [rR] [eE]; + WINDOW: [wW] [iI] [nN] [dD] [oO] [wW]; + WITH: [wW] [iI] [tT] [hH]; // last RESERVED_KEYWORD, sync with AntlrUtils.normalizeWhitespaceUnquoted + + /* + * Other tokens. + * Some sql words/data types are not keywords but we need a token to be able to parse them. + */ + + ALIGNMENT: [aA] [lL] [iI] [gG] [nN] [mM] [eE] [nN] [tT]; + + BASETYPE: [bB] [aA] [sS] [eE] [tT] [yY] [pP] [eE]; + BUFFERS: [bB] [uU] [fF] [fF] [eE] [rR] [sS]; + BYPASSRLS: [bB] [yY] [pP] [aA] [sS] [sS] [rR] [lL] [sS]; + + CANONICAL: [cC] [aA] [nN] [oO] [nN] [iI] [cC] [aA] [lL]; + CATEGORY: [cC] [aA] [tT] [eE] [gG] [oO] [rR] [yY]; + COLLATABLE: [cC] [oO] [lL] [lL] [aA] [tT] [aA] [bB] [lL] [eE]; + COMBINEFUNC: [cC] [oO] [mM] [bB] [iI] [nN] [eE] [fF] [uU] [nN] [cC]; + COMMUTATOR: [cC] [oO] [mM] [mM] [uU] [tT] [aA] [tT] [oO] [rR]; + CONNECT: [cC] [oO] [nN] [nN] [eE] [cC] [tT]; + COSTS: [cC] [oO] [sS] [tT] [sS]; + CREATEDB: [cC] [rR] [eE] [aA] [tT] [eE] [dD] [bB]; + CREATEROLE: [cC] [rR] [eE] [aA] [tT] [eE] [rR] [oO] [lL] [eE]; + + DESERIALFUNC: [dD] [eE] [sS] [eE] [rR] [iI] [aA] [lL] [fF] [uU] [nN] [cC]; + DETERMINISTIC: [dD] [eE] [tT] [eE] [rR] [mM] [iI] [nN] [iI] [sS] [tT] [iI] [cC]; + DISABLE_PAGE_SKIPPING: DISABLE UNDERLINE [pP] [aA] [gG] [eE] UNDERLINE [sS] [kK] [iI] [pP] [pP] [iI] [nN] [gG]; + + ELEMENT: [eE] [lL] [eE] [mM] [eE] [nN] [tT]; + EXTENDED: [eE] [xX] [tT] [eE] [nN] [dD] [eE] [dD]; + + FINALFUNC: [fF] [iI] [nN] [aA] [lL] [fF] [uU] [nN] [cC]; + FINALFUNC_EXTRA: FINALFUNC UNDERLINE [eE] [xX] [tT] [rR] [aA]; + FINALFUNC_MODIFY: FINALFUNC UNDERLINE [mM] [oO] [dD] [iI] [fF] [yY]; + FORCE_NOT_NULL: [fF] [oO] [rR] [cC] [eE] UNDERLINE [nN] [oO] [tT] UNDERLINE [nN] [uU] [lL] [lL]; + FORCE_NULL: [fF] [oO] [rR] [cC] [eE] UNDERLINE [nN] [uU] [lL] [lL]; + FORCE_QUOTE: [fF] [oO] [rR] [cC] [eE] UNDERLINE [qQ] [uU] [oO] [tT] [eE]; + FORMAT: [fF] [oO] [rR] [mM] [aA] [tT]; + + GETTOKEN: [gG] [eE] [tT] [tT] [oO] [kK] [eE] [nN]; + + HASH: [hH] [aA] [sS] [hH]; + HASHES: [hH] [aA] [sS] [hH] [eE] [sS]; + HEADLINE: [hH] [eE] [aA] [dD] [lL] [iI] [nN] [eE]; + HYPOTHETICAL: [hH] [yY] [pP] [oO] [tT] [hH] [eE] [tT] [iI] [cC] [aA] [lL]; + + INDEX_CLEANUP: [iI] [nN] [dD] [eE] [xX] UNDERLINE [cC] [lL] [eE] [aA] [nN] [uU] [pP]; + INIT: [iI] [nN] [iI] [tT]; + INITCOND: [iI] [nN] [iI] [tT] [cC] [oO] [nN] [dD]; + INTERNALLENGTH: [iI] [nN] [tT] [eE] [rR] [nN] [aA] [lL] [lL] [eE] [nN] [gG] [tT] [hH]; + + JSON: [jJ] [sS] [oO] [nN]; + + LC_COLLATE: [lL] [cC] UNDERLINE [cC] [oO] [lL] [lL] [aA] [tT] [eE]; + LC_CTYPE: [lL] [cC] UNDERLINE [cC] [tT] [yY] [pP] [eE]; + LEFTARG: [lL] [eE] [fF] [tT] [aA] [rR] [gG]; + LEXIZE: [lL] [eE] [xX] [iI] [zZ] [eE]; + LEXTYPES: [lL] [eE] [xX] [tT] [yY] [pP] [eE] [sS]; + LIST: [lL] [iI] [sS] [tT]; + LOCALE: [lL] [oO] [cC] [aA] [lL] [eE]; + LOGIN: [lL] [oO] [gG] [iI] [nN]; + + MAIN: [mM] [aA] [iI] [nN]; + MERGES: [mM] [eE] [rR] [gG] [eE] [sS]; + MFINALFUNC: [mM] [fF] [iI] [nN] [aA] [lL] [fF] [uU] [nN] [cC]; + MFINALFUNC_EXTRA: MFINALFUNC UNDERLINE [eE] [xX] [tT] [rR] [aA]; + MFINALFUNC_MODIFY: MFINALFUNC UNDERLINE [mM] [oO] [dD] [iI] [fF] [yY]; + MINITCOND: [mM] [iI] [nN] [iI] [tT] [cC] [oO] [nN] [dD]; + MINVFUNC: [mM] [iI] [nN] [vV] [fF] [uU] [nN] [cC]; + MODULUS: [mM] [oO] [dD] [uU] [lL] [uU] [sS]; + MSFUNC: [mM] [sS] [fF] [uU] [nN] [cC]; + MSSPACE: [mM] [sS] [sS] [pP] [aA] [cC] [eE]; + MSTYPE: [mM] [sS] [tT] [yY] [pP] [eE]; + + NEGATOR: [nN] [eE] [gG] [aA] [tT] [oO] [rR]; + NOBYPASSRLS: [nN] [oO] [bB] [yY] [pP] [aA] [sS] [sS] [rR] [lL] [sS]; + NOCREATEDB: [nN] [oO] [cC] [rR] [eE] [aA] [tT] [eE] [dD] [bB]; + NOCREATEROLE: [nN] [oO] [cC] [rR] [eE] [aA] [tT] [eE] [rR] [oO] [lL] [eE]; + NOINHERIT: [nN] [oO] [iI] [nN] [hH] [eE] [rR] [iI] [tT]; + NOLOGIN: [nN] [oO] [lL] [oO] [gG] [iI] [nN]; + NOREPLICATION: [nN] [oO] [rR] [eE] [pP] [lL] [iI] [cC] [aA] [tT] [iI] [oO] [nN]; + NOSUPERUSER: [nN] [oO] [sS] [uU] [pP] [eE] [rR] [uU] [sS] [eE] [rR]; + + OUTPUT: [oO] [uU] [tT] [pP] [uU] [tT]; + + PASSEDBYVALUE: [pP] [aA] [sS] [sS] [eE] [dD] [bB] [yY] [vV] [aA] [lL] [uU] [eE]; + PATH: [pP] [aA] [tT] [hH]; + PERMISSIVE: [pP] [eE] [rR] [mM] [iI] [sS] [sS] [iI] [vV] [eE]; + PLAIN: [pP] [lL] [aA] [iI] [nN]; + PREFERRED: [pP] [rR] [eE] [fF] [eE] [rR] [rR] [eE] [dD]; + PROVIDER: [pP] [rR] [oO] [vV] [iI] [dD] [eE] [rR]; + + READ_ONLY: READ UNDERLINE ONLY; + READ_WRITE: READ UNDERLINE WRITE; + RECEIVE: [rR] [eE] [cC] [eE] [iI] [vV] [eE]; + REMAINDER: [rR] [eE] [mM] [aA] [iI] [nN] [dD] [eE] [rR]; + REPLICATION: [rR] [eE] [pP] [lL] [iI] [cC] [aA] [tT] [iI] [oO] [nN]; + RESTRICTED: [rR] [eE] [sS] [tT] [rR] [iI] [cC] [tT] [eE] [dD]; + RESTRICTIVE: [rR] [eE] [sS] [tT] [rR] [iI] [cC] [tT] [iI] [vV] [eE]; + RIGHTARG: [rR] [iI] [gG] [hH] [tT] [aA] [rR] [gG]; + + SAFE: [sS] [aA] [fF] [eE]; + SEND: [sS] [eE] [nN] [dD]; + SERIALFUNC: [sS] [eE] [rR] [iI] [aA] [lL] [fF] [uU] [nN] [cC]; + SETTINGS: [sS] [eE] [tT] [tT] [iI] [nN] [gG] [sS]; + SFUNC: [sS] [fF] [uU] [nN] [cC]; + SHAREABLE: [sS] [hH] [aA] [rR] [eE] [aA] [bB] [lL] [eE]; + SKIP_LOCKED: [sS] [kK] [iI] [pP] UNDERLINE [lL] [oO] [cC] [kK] [eE] [dD]; + SORTOP: [sS] [oO] [rR] [tT] [oO] [pP]; + SSPACE: [sS] [sS] [pP] [aA] [cC] [eE]; + STYPE: [sS] [tT] [yY] [pP] [eE]; + SUBTYPE_DIFF: [sS] [uU] [bB] [tT] [yY] [pP] [eE] UNDERLINE [dD] [iI] [fF] [fF]; + SUBTYPE_OPCLASS: [sS] [uU] [bB] [tT] [yY] [pP] [eE] UNDERLINE [oO] [pP] [cC] [lL] [aA] [sS] [sS]; + SUBTYPE: [sS] [uU] [bB] [tT] [yY] [pP] [eE]; + SUMMARY: [sS] [uU] [mM] [mM] [aA] [rR] [yY]; + SUPERUSER: [sS] [uU] [pP] [eE] [rR] [uU] [sS] [eE] [rR]; + + TIMING: [tT] [iI] [mM] [iI] [nN] [gG]; + TYPMOD_IN: [tT] [yY] [pP] [mM] [oO] [dD] UNDERLINE [iI] [nN]; + TYPMOD_OUT: [tT] [yY] [pP] [mM] [oO] [dD] UNDERLINE [oO] [uU] [tT]; + + UNSAFE: [uU] [nN] [sS] [aA] [fF] [eE]; + USAGE: [uU] [sS] [aA] [gG] [eE]; + + VARIABLE: [vV] [aA] [rR] [iI] [aA] [bB] [lL] [eE]; + + YAML: [yY] [aA] [mM] [lL]; + + // plpgsql tokens + + ALIAS: [aA] [lL] [iI] [aA] [sS]; + ASSERT: [aA] [sS] [sS] [eE] [rR] [tT]; + + CONSTANT: [cC] [oO] [nN] [sS] [tT] [aA] [nN] [tT]; + + DATATYPE: [dD] [aA] [tT] [aA] [tT] [yY] [pP] [eE]; + DEBUG: [dD] [eE] [bB] [uU] [gG]; + DETAIL: [dD] [eE] [tT] [aA] [iI] [lL]; + DIAGNOSTICS: [dD] [iI] [aA] [gG] [nN] [oO] [sS] [tT] [iI] [cC] [sS]; + + ELSEIF: [eE] [lL] [sS] [eE] [iI] [fF]; + ELSIF: [eE] [lL] [sS] [iI] [fF]; + ERRCODE: [eE] [rR] [rR] [cC] [oO] [dD] [eE]; + EXIT: [eE] [xX] [iI] [tT]; + EXCEPTION: [eE] [xX] [cC] [eE] [pP] [tT] [iI] [oO] [nN]; + + FOREACH: [fF] [oO] [rR] [eE] [aA] [cC] [hH]; + + GET: [gG] [eE] [tT]; + + HINT: [hH] [iI] [nN] [tT]; + + INFO: [iI] [nN] [fF] [oO]; + + LOG: [lL] [oO] [gG]; + LOOP: [lL] [oO] [oO] [pP]; + + MESSAGE: [mM] [eE] [sS] [sS] [aA] [gG] [eE]; + + NOTICE: [nN] [oO] [tT] [iI] [cC] [eE]; + + OPEN: [oO] [pP] [eE] [nN]; + + PERFORM: [pP] [eE] [rR] [fF] [oO] [rR] [mM]; + + QUERY: [qQ] [uU] [eE] [rR] [yY]; + + RAISE: [rR] [aA] [iI] [sS] [eE]; + RECORD: [rR] [eE] [cC] [oO] [rR] [dD]; + RETURN: [rR] [eE] [tT] [uU] [rR] [nN]; + REVERSE: [rR] [eE] [vV] [eE] [rR] [sS] [eE]; + ROWTYPE: [rR] [oO] [wW] [tT] [yY] [pP] [eE]; + + SLICE: [sS] [lL] [iI] [cC] [eE]; + SQLSTATE: [sS] [qQ] [lL] [sS] [tT] [aA] [tT] [eE]; + STACKED: [sS] [tT] [aA] [cC] [kK] [eE] [dD]; + + WARNING: [wW] [aA] [rR] [nN] [iI] [nN] [gG]; + WHILE: [wW] [hH] [iI] [lL] [eE]; // last identifier rule, sync with CustomSQLAntlrErrorStrategy + +fragment UNDERLINE : '_'; + +// Operators + +// Cast Operator +CAST_EXPRESSION : ':' ':'; // first operator rule, sync with CustomSQLAntlrErrorStrategy + +EQUAL : '='; +COLON : ':'; +SEMI_COLON : ';'; +COMMA : ','; +NOT_EQUAL : '<>' | '!='; +LTH : '<'; +LEQ : '<='; +GTH : '>'; +GEQ : '>='; +LEFT_PAREN : '('; +RIGHT_PAREN : ')'; +PLUS : '+'; +MINUS : '-'; +MULTIPLY: '*'; +DIVIDE : '/'; +MODULAR : '%'; +EXP : '^'; + +DOT : '.'; +QUOTE_CHAR : '\''; +DOUBLE_QUOTE : '"'; +DOLLAR : '$'; +LEFT_BRACKET : '['; +RIGHT_BRACKET : ']'; + +EQUAL_GTH : '=>'; +COLON_EQUAL : ':='; + +LESS_LESS : '<<'; +GREATER_GREATER : '>>'; +DOUBLE_DOT: '..'; +HASH_SIGN: '#'; // last operator rule, sync with CustomSQLAntlrErrorStrategy + +BlockComment + : '/*' (BlockComment |.)*? '*/' -> channel(HIDDEN) + ; + +LineComment + : '--' ~[\r\n]* -> channel(HIDDEN) + ; + +// must follow all explicitly defined operators and comments +// so that they are matched first +OP_CHARS + // may not end with + or - + : OperatorBasic+ OperatorBasicEnd + // may end with any character but must include at least one of OperatorSpecial + | (OperatorBasic | OperatorSpecial)* OperatorSpecial (OperatorBasic | OperatorSpecial)* + ; + +fragment +OperatorBasic + : [+*<>=] + // check so that comment start sequences are not matched by this + | '-' {}? + | '/' {}?; +fragment +OperatorBasicEnd: [*/<>=]; +fragment +OperatorSpecial: [~!@#%^&|`?]; + +NUMBER_LITERAL : Digit+; + +fragment +Digit : '0'..'9'; + +REAL_NUMBER + // fail double dots into a separate token + // otherwise 1..10 would lex into 2 numbers + : Digit+ '.' {}? + | Digit+ '.' Digit+ EXPONENT? + | Digit+ '.' EXPONENT + | '.' Digit+ EXPONENT? + | Digit+ EXPONENT + ; + +DOLLAR_NUMBER + : DOLLAR NUMBER_LITERAL + ; + +/* +=============================================================================== + Identifiers +=============================================================================== +*/ + +Identifier + : IdentifierStartChar IdentifierChar* + // always lowercase unquoted ids + {} + ; +fragment +IdentifierStartChar + : // these are the valid identifier start characters below 0x7F + [a-zA-Z_] + | // these are the valid characters from 0x80 to 0xFF + [\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF] + | // these are the letters above 0xFF which only need a single UTF-16 code unit + [\u0100-\uD7FF\uE000-\uFFFF] {}? + | // letters which require multiple UTF-16 code units + [\uD800-\uDBFF] [\uDC00-\uDFFF] {}? + ; +fragment +IdentifierChar + : StrictIdentifierChar + | '$' + ; +fragment +StrictIdentifierChar + : IdentifierStartChar + | [0-9] + ; + +/* Quoted Identifiers +* +* These are divided into four separate tokens, allowing distinction of valid quoted identifiers from invalid quoted +* identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in the input. +*/ +QuotedIdentifier + : UnterminatedQuotedIdentifier '"' + // unquote so that we may always call getText() and not worry about quotes + { + } + ; +// This is a quoted identifier which only contains valid characters but is not terminated +fragment UnterminatedQuotedIdentifier + : '"' + ( '""' | ~[\u0000"] )* + ; +/* +=============================================================================== + Literal +=============================================================================== +*/ + +// Some Unicode Character Ranges +fragment +Control_Characters : '\u0001' .. '\u0008' | '\u000B' | '\u000C' | '\u000E' .. '\u001F'; +fragment +Extended_Control_Characters : '\u0080' .. '\u009F'; + +Character_String_Literal + : [eEnNxXbB]? Single_String (String_Joiner Single_String)* + ; + +fragment +Single_String + : QUOTE_CHAR ( ~'\'' | '\'\'')* QUOTE_CHAR + ; + +fragment +String_Joiner + : ((Space | Tab | White_Space | LineComment)* New_Line)+ (Space | Tab | White_Space)* + ; + +fragment +EXPONENT : ('e'|'E') ('+'|'-')? Digit+ ; + +// Dollar-quoted String Constants (ยง4.1.2.4) +BeginDollarStringConstant + : '$' Tag? '$' {} -> pushMode(DollarQuotedStringMode) + ; + +fragment +Tag + : IdentifierStartChar StrictIdentifierChar* + ; + + +/* +=============================================================================== + Whitespace Tokens +=============================================================================== +*/ + +Space + : ' ' -> channel(HIDDEN) + ; + +White_Space + : ( Control_Characters | Extended_Control_Characters )+ -> channel(HIDDEN) + ; + +New_Line + : ('\u000D' | '\u000D'? '\u000A') -> channel(HIDDEN) + ; + +Tab + : '\u0009' -> channel(HIDDEN) + ; + +BOM: '\ufeff'; + +BAD + : . + ; + +mode DollarQuotedStringMode; +Text_between_Dollar + : ~'$'+ + | // this alternative improves the efficiency of handling $ characters within a dollar-quoted string which are + // not part of the ending tag. + '$' ~'$'* + ; + +EndDollarStringConstant + : '$' Tag? '$' {}? {} -> popMode + ; diff --git a/sql_to_code/parsers/generated/PLpgSQLLexer.interp b/sql_to_code/parsers/generated/PLpgSQLLexer.interp new file mode 100644 index 0000000..4f4ac41 --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLLexer.interp @@ -0,0 +1,1899 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'=' +':' +';' +',' +null +'<' +'<=' +'>' +'>=' +'(' +')' +'+' +'-' +'*' +'/' +'%' +'^' +'.' +'\'' +'"' +'$' +'[' +']' +'=>' +':=' +'<<' +'>>' +'..' +'#' +null +null +null +null +null +null +null +null +null +null +' ' +null +null +'\u0009' +'\ufeff' +null +null +null + +token symbolic names: +null +ABORT +ABSOLUTE +ACCESS +ACTION +ADD +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTACH +ATTRIBUTE +BACKWARD +BEFORE +BEGIN +BY +CACHE +CALL +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COLUMNS +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONFLICT +CONNECTION +CONSTRAINTS +CONTENT +CONTINUE +CONVERSION +COPY +COST +CSV +CUBE +CURRENT +CURSOR +CYCLE +DATA +DATABASE +DAY +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE +DELIMITER +DELIMITERS +DEPENDS +DETACH +DICTIONARY +DISABLE +DISCARD +DOCUMENT +DOMAIN +DOUBLE +DROP +EACH +ENABLE +ENCODING +ENCRYPTED +ENUM +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FILTER +FIRST +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GENERATED +GLOBAL +GRANTED +GROUPS +HANDLER +HEADER +HOLD +HOUR +IDENTITY +IF +IMMEDIATE +IMMUTABLE +IMPLICIT +IMPORT +INCLUDE +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE +INPUT +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE +LAST +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK +LOCKED +LOGGED +MAPPING +MATCH +MATERIALIZED +MAXVALUE +METHOD +MINUTE +MINVALUE +MODE +MONTH +MOVE +NAME +NAMES +NEW +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS +OBJECT +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 +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROLLUP +ROUTINE +ROUTINES +ROWS +RULE +SAVEPOINT +SCHEMA +SCHEMAS +SCROLL +SEARCH +SECOND +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SETS +SHARE +SHOW +SIMPLE +SKIP_ +SNAPSHOT +SQL +STABLE +STANDALONE +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STORED +STRICT +STRIP +SUBSCRIPTION +SUPPORT +SYSID +SYSTEM +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT +TIES +TRANSACTION +TRANSFORM +TRIGGER +TRUNCATE +TRUSTED +TYPE +TYPES +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VALUE +VARYING +VERSION +VIEW +VIEWS +VOLATILE +WHITESPACE +WITHIN +WITHOUT +WORK +WRAPPER +WRITE +XML +YEAR +YES +ZONE +BETWEEN +BIGINT +BIT +BOOLEAN +CHAR +CHARACTER +COALESCE +DEC +DECIMAL +EXISTS +EXTRACT +FLOAT +GREATEST +GROUPING +INOUT +INT +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OUT +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 +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER +OVERLAPS +RIGHT +SIMILAR +TABLESAMPLE +VERBOSE +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 +EXCEPT +FALSE +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP +HAVING +IN +INITIALLY +INTERSECT +INTO +LATERAL +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +ALIGNMENT +BASETYPE +BUFFERS +BYPASSRLS +CANONICAL +CATEGORY +COLLATABLE +COMBINEFUNC +COMMUTATOR +CONNECT +COSTS +CREATEDB +CREATEROLE +DESERIALFUNC +DETERMINISTIC +DISABLE_PAGE_SKIPPING +ELEMENT +EXTENDED +FINALFUNC +FINALFUNC_EXTRA +FINALFUNC_MODIFY +FORCE_NOT_NULL +FORCE_NULL +FORCE_QUOTE +FORMAT +GETTOKEN +HASH +HASHES +HEADLINE +HYPOTHETICAL +INDEX_CLEANUP +INIT +INITCOND +INTERNALLENGTH +JSON +LC_COLLATE +LC_CTYPE +LEFTARG +LEXIZE +LEXTYPES +LIST +LOCALE +LOGIN +MAIN +MERGES +MFINALFUNC +MFINALFUNC_EXTRA +MFINALFUNC_MODIFY +MINITCOND +MINVFUNC +MODULUS +MSFUNC +MSSPACE +MSTYPE +NEGATOR +NOBYPASSRLS +NOCREATEDB +NOCREATEROLE +NOINHERIT +NOLOGIN +NOREPLICATION +NOSUPERUSER +OUTPUT +PASSEDBYVALUE +PATH +PERMISSIVE +PLAIN +PREFERRED +PROVIDER +READ_ONLY +READ_WRITE +RECEIVE +REMAINDER +REPLICATION +RESTRICTED +RESTRICTIVE +RIGHTARG +SAFE +SEND +SERIALFUNC +SETTINGS +SFUNC +SHAREABLE +SKIP_LOCKED +SORTOP +SSPACE +STYPE +SUBTYPE_DIFF +SUBTYPE_OPCLASS +SUBTYPE +SUMMARY +SUPERUSER +TIMING +TYPMOD_IN +TYPMOD_OUT +UNSAFE +USAGE +VARIABLE +YAML +ALIAS +ASSERT +CONSTANT +DATATYPE +DEBUG +DETAIL +DIAGNOSTICS +ELSEIF +ELSIF +ERRCODE +EXIT +EXCEPTION +FOREACH +GET +HINT +INFO +LOG +LOOP +MESSAGE +NOTICE +OPEN +PERFORM +QUERY +RAISE +RECORD +RETURN +REVERSE +ROWTYPE +SLICE +SQLSTATE +STACKED +WARNING +WHILE +CAST_EXPRESSION +EQUAL +COLON +SEMI_COLON +COMMA +NOT_EQUAL +LTH +LEQ +GTH +GEQ +LEFT_PAREN +RIGHT_PAREN +PLUS +MINUS +MULTIPLY +DIVIDE +MODULAR +EXP +DOT +QUOTE_CHAR +DOUBLE_QUOTE +DOLLAR +LEFT_BRACKET +RIGHT_BRACKET +EQUAL_GTH +COLON_EQUAL +LESS_LESS +GREATER_GREATER +DOUBLE_DOT +HASH_SIGN +BlockComment +LineComment +OP_CHARS +NUMBER_LITERAL +REAL_NUMBER +DOLLAR_NUMBER +Identifier +QuotedIdentifier +Character_String_Literal +BeginDollarStringConstant +Space +White_Space +New_Line +Tab +BOM +BAD +Text_between_Dollar +EndDollarStringConstant + +rule names: +ABORT +ABSOLUTE +ACCESS +ACTION +ADD +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTACH +ATTRIBUTE +BACKWARD +BEFORE +BEGIN +BY +CACHE +CALL +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COLUMNS +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONFLICT +CONNECTION +CONSTRAINTS +CONTENT +CONTINUE +CONVERSION +COPY +COST +CSV +CUBE +CURRENT +CURSOR +CYCLE +DATA +DATABASE +DAY +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE +DELIMITER +DELIMITERS +DEPENDS +DETACH +DICTIONARY +DISABLE +DISCARD +DOCUMENT +DOMAIN +DOUBLE +DROP +EACH +ENABLE +ENCODING +ENCRYPTED +ENUM +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FILTER +FIRST +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GENERATED +GLOBAL +GRANTED +GROUPS +HANDLER +HEADER +HOLD +HOUR +IDENTITY +IF +IMMEDIATE +IMMUTABLE +IMPLICIT +IMPORT +INCLUDE +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE +INPUT +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE +LAST +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK +LOCKED +LOGGED +MAPPING +MATCH +MATERIALIZED +MAXVALUE +METHOD +MINUTE +MINVALUE +MODE +MONTH +MOVE +NAME +NAMES +NEW +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS +OBJECT +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 +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROLLUP +ROUTINE +ROUTINES +ROWS +RULE +SAVEPOINT +SCHEMA +SCHEMAS +SCROLL +SEARCH +SECOND +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SETS +SHARE +SHOW +SIMPLE +SKIP_ +SNAPSHOT +SQL +STABLE +STANDALONE +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STORED +STRICT +STRIP +SUBSCRIPTION +SUPPORT +SYSID +SYSTEM +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT +TIES +TRANSACTION +TRANSFORM +TRIGGER +TRUNCATE +TRUSTED +TYPE +TYPES +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VALUE +VARYING +VERSION +VIEW +VIEWS +VOLATILE +WHITESPACE +WITHIN +WITHOUT +WORK +WRAPPER +WRITE +XML +YEAR +YES +ZONE +BETWEEN +BIGINT +BIT +BOOLEAN +CHAR +CHARACTER +COALESCE +DEC +DECIMAL +EXISTS +EXTRACT +FLOAT +GREATEST +GROUPING +INOUT +INT +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OUT +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 +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER +OVERLAPS +RIGHT +SIMILAR +TABLESAMPLE +VERBOSE +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 +EXCEPT +FALSE +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP +HAVING +IN +INITIALLY +INTERSECT +INTO +LATERAL +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +ALIGNMENT +BASETYPE +BUFFERS +BYPASSRLS +CANONICAL +CATEGORY +COLLATABLE +COMBINEFUNC +COMMUTATOR +CONNECT +COSTS +CREATEDB +CREATEROLE +DESERIALFUNC +DETERMINISTIC +DISABLE_PAGE_SKIPPING +ELEMENT +EXTENDED +FINALFUNC +FINALFUNC_EXTRA +FINALFUNC_MODIFY +FORCE_NOT_NULL +FORCE_NULL +FORCE_QUOTE +FORMAT +GETTOKEN +HASH +HASHES +HEADLINE +HYPOTHETICAL +INDEX_CLEANUP +INIT +INITCOND +INTERNALLENGTH +JSON +LC_COLLATE +LC_CTYPE +LEFTARG +LEXIZE +LEXTYPES +LIST +LOCALE +LOGIN +MAIN +MERGES +MFINALFUNC +MFINALFUNC_EXTRA +MFINALFUNC_MODIFY +MINITCOND +MINVFUNC +MODULUS +MSFUNC +MSSPACE +MSTYPE +NEGATOR +NOBYPASSRLS +NOCREATEDB +NOCREATEROLE +NOINHERIT +NOLOGIN +NOREPLICATION +NOSUPERUSER +OUTPUT +PASSEDBYVALUE +PATH +PERMISSIVE +PLAIN +PREFERRED +PROVIDER +READ_ONLY +READ_WRITE +RECEIVE +REMAINDER +REPLICATION +RESTRICTED +RESTRICTIVE +RIGHTARG +SAFE +SEND +SERIALFUNC +SETTINGS +SFUNC +SHAREABLE +SKIP_LOCKED +SORTOP +SSPACE +STYPE +SUBTYPE_DIFF +SUBTYPE_OPCLASS +SUBTYPE +SUMMARY +SUPERUSER +TIMING +TYPMOD_IN +TYPMOD_OUT +UNSAFE +USAGE +VARIABLE +YAML +ALIAS +ASSERT +CONSTANT +DATATYPE +DEBUG +DETAIL +DIAGNOSTICS +ELSEIF +ELSIF +ERRCODE +EXIT +EXCEPTION +FOREACH +GET +HINT +INFO +LOG +LOOP +MESSAGE +NOTICE +OPEN +PERFORM +QUERY +RAISE +RECORD +RETURN +REVERSE +ROWTYPE +SLICE +SQLSTATE +STACKED +WARNING +WHILE +UNDERLINE +CAST_EXPRESSION +EQUAL +COLON +SEMI_COLON +COMMA +NOT_EQUAL +LTH +LEQ +GTH +GEQ +LEFT_PAREN +RIGHT_PAREN +PLUS +MINUS +MULTIPLY +DIVIDE +MODULAR +EXP +DOT +QUOTE_CHAR +DOUBLE_QUOTE +DOLLAR +LEFT_BRACKET +RIGHT_BRACKET +EQUAL_GTH +COLON_EQUAL +LESS_LESS +GREATER_GREATER +DOUBLE_DOT +HASH_SIGN +BlockComment +LineComment +OP_CHARS +OperatorBasic +OperatorBasicEnd +OperatorSpecial +NUMBER_LITERAL +Digit +REAL_NUMBER +DOLLAR_NUMBER +Identifier +IdentifierStartChar +IdentifierChar +StrictIdentifierChar +QuotedIdentifier +UnterminatedQuotedIdentifier +Control_Characters +Extended_Control_Characters +Character_String_Literal +Single_String +String_Joiner +EXPONENT +BeginDollarStringConstant +Tag +Space +White_Space +New_Line +Tab +BOM +BAD +Text_between_Dollar +EndDollarStringConstant + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE +DollarQuotedStringMode + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 624, 6126, 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, 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, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 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, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 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, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 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, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 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, 48, 3, 48, 3, 48, 3, 48, 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, 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, 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, 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, 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, 58, 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, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 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, 64, 3, 65, 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, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 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, 69, 3, 69, 3, 69, 3, 69, 3, 70, 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, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 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, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 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, 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, 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, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 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, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 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, 90, 3, 90, 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, 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, 93, 3, 93, 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, 95, 3, 95, 3, 95, 3, 95, 3, 95, 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, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 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, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 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, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 108, 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, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 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, 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, 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, 115, 3, 115, 3, 115, 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, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 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, 120, 3, 120, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 129, 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, 131, 3, 131, 3, 131, 3, 131, 3, 131, 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, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 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, 140, 3, 140, 3, 140, 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, 142, 3, 142, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 149, 3, 149, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 153, 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, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 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, 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, 164, 3, 164, 3, 164, 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, 167, 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, 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, 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, 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, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 176, 3, 176, 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, 178, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 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, 181, 3, 181, 3, 181, 3, 181, 3, 181, 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, 183, 3, 183, 3, 183, 3, 184, 3, 184, 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, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 187, 3, 187, 3, 187, 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, 188, 3, 188, 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, 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, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 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, 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, 201, 3, 201, 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, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 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, 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, 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, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 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, 212, 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, 214, 3, 214, 3, 214, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 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, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 223, 3, 223, 3, 223, 3, 223, 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, 225, 3, 225, 3, 225, 3, 225, 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, 226, 3, 226, 3, 226, 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, 229, 3, 229, 3, 229, 3, 229, 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, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 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, 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, 238, 3, 238, 3, 238, 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, 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, 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, 244, 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, 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, 249, 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, 251, 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, 253, 3, 253, 3, 253, 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, 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, 256, 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, 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, 260, 3, 261, 3, 261, 3, 261, 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, 262, 3, 263, 3, 263, 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, 265, 3, 265, 3, 265, 3, 266, 3, 266, 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, 267, 3, 267, 3, 267, 3, 267, 3, 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, 269, 3, 269, 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, 270, 3, 270, 3, 271, 3, 271, 3, 271, 3, 271, 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, 273, 3, 273, 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, 276, 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, 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, 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, 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, 284, 3, 284, 3, 284, 3, 284, 3, 284, 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, 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, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 292, 3, 292, 3, 292, 3, 292, 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, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 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, 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, 300, 3, 300, 3, 300, 3, 300, 3, 300, 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, 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, 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, 307, 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, 311, 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, 313, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 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, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 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, 321, 3, 321, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 323, 3, 323, 3, 323, 3, 323, 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, 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, 328, 3, 328, 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, 329, 3, 329, 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, 333, 3, 333, 3, 333, 3, 333, 3, 333, 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, 336, 3, 336, 3, 336, 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, 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, 338, 3, 338, 3, 338, 3, 339, 3, 339, 3, 339, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 366, 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, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 370, 3, 370, 3, 370, 3, 370, 3, 371, 3, 371, 3, 371, 3, 371, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 373, 3, 373, 3, 373, 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, 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, 378, 3, 378, 3, 378, 3, 378, 3, 378, 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, 381, 3, 381, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 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, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 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, 386, 3, 386, 3, 386, 3, 386, 3, 386, 3, 387, 3, 387, 3, 387, 3, 387, 3, 387, 3, 387, 3, 387, 3, 387, 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, 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, 389, 3, 389, 3, 389, 3, 389, 3, 390, 3, 390, 3, 390, 3, 390, 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, 391, 3, 391, 3, 391, 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, 393, 3, 394, 3, 394, 3, 394, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 396, 3, 396, 3, 396, 3, 396, 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, 399, 3, 399, 3, 399, 3, 399, 3, 399, 3, 399, 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, 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, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 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, 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, 410, 3, 410, 3, 410, 3, 410, 3, 411, 3, 411, 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, 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, 414, 3, 414, 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, 416, 3, 416, 3, 416, 3, 416, 3, 416, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 418, 3, 418, 3, 418, 3, 419, 3, 419, 3, 419, 3, 419, 3, 419, 3, 420, 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, 422, 3, 422, 3, 422, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 425, 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, 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, 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, 430, 3, 430, 3, 430, 3, 430, 3, 430, 3, 430, 3, 431, 3, 431, 3, 431, 3, 431, 3, 431, 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, 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, 437, 3, 437, 3, 437, 3, 437, 3, 437, 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, 440, 3, 440, 3, 440, 3, 440, 3, 440, 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, 444, 3, 444, 3, 444, 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, 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, 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, 449, 3, 449, 3, 450, 3, 450, 3, 450, 3, 450, 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, 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, 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, 455, 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, 457, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 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, 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, 461, 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, 463, 3, 463, 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, 464, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 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, 466, 3, 466, 3, 466, 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, 467, 3, 467, 3, 467, 3, 467, 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, 472, 3, 472, 3, 472, 3, 472, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 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, 474, 3, 474, 3, 474, 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, 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, 477, 3, 477, 3, 477, 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, 479, 3, 479, 3, 480, 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, 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, 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, 487, 3, 487, 3, 487, 3, 487, 3, 487, 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, 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, 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, 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, 495, 3, 495, 3, 495, 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, 498, 3, 498, 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, 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, 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, 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, 504, 3, 504, 3, 504, 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, 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, 507, 3, 507, 3, 507, 3, 507, 3, 507, 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, 509, 3, 509, 3, 509, 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, 511, 3, 511, 3, 511, 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, 512, 3, 513, 3, 513, 3, 513, 3, 513, 3, 514, 3, 514, 3, 514, 3, 514, 3, 515, 3, 515, 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, 516, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 519, 3, 519, 3, 519, 3, 519, 3, 519, 3, 519, 3, 519, 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, 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, 523, 3, 523, 3, 523, 3, 523, 3, 523, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 525, 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, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 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, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 530, 3, 530, 3, 530, 3, 530, 3, 530, 3, 530, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 536, 3, 536, 3, 536, 3, 536, 3, 536, 3, 536, 3, 536, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 540, 3, 540, 3, 540, 3, 540, 3, 540, 3, 540, 3, 541, 3, 541, 3, 541, 3, 541, 3, 541, 3, 541, 3, 541, 3, 541, 3, 541, 3, 542, 3, 542, 3, 542, 3, 542, 3, 542, 3, 543, 3, 543, 3, 543, 3, 543, 3, 543, 3, 543, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 546, 3, 546, 3, 546, 3, 546, 3, 546, 3, 546, 3, 546, 3, 546, 3, 546, 3, 547, 3, 547, 3, 547, 3, 547, 3, 547, 3, 547, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 550, 3, 550, 3, 550, 3, 550, 3, 550, 3, 550, 3, 550, 3, 551, 3, 551, 3, 551, 3, 551, 3, 551, 3, 551, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 556, 3, 556, 3, 556, 3, 556, 3, 557, 3, 557, 3, 557, 3, 557, 3, 557, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 559, 3, 559, 3, 559, 3, 559, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 563, 3, 563, 3, 563, 3, 563, 3, 563, 3, 564, 3, 564, 3, 564, 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, 566, 3, 567, 3, 567, 3, 567, 3, 567, 3, 567, 3, 567, 3, 567, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 3, 569, 3, 569, 3, 569, 3, 569, 3, 569, 3, 569, 3, 569, 3, 569, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 571, 3, 571, 3, 571, 3, 571, 3, 571, 3, 571, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 576, 3, 576, 3, 577, 3, 577, 3, 577, 3, 578, 3, 578, 3, 579, 3, 579, 3, 580, 3, 580, 3, 581, 3, 581, 3, 582, 3, 582, 3, 582, 3, 582, 5, 582, 5786, 10, 582, 3, 583, 3, 583, 3, 584, 3, 584, 3, 584, 3, 585, 3, 585, 3, 586, 3, 586, 3, 586, 3, 587, 3, 587, 3, 588, 3, 588, 3, 589, 3, 589, 3, 590, 3, 590, 3, 591, 3, 591, 3, 592, 3, 592, 3, 593, 3, 593, 3, 594, 3, 594, 3, 595, 3, 595, 3, 596, 3, 596, 3, 597, 3, 597, 3, 598, 3, 598, 3, 599, 3, 599, 3, 600, 3, 600, 3, 601, 3, 601, 3, 601, 3, 602, 3, 602, 3, 602, 3, 603, 3, 603, 3, 603, 3, 604, 3, 604, 3, 604, 3, 605, 3, 605, 3, 605, 3, 606, 3, 606, 3, 607, 3, 607, 3, 607, 3, 607, 3, 607, 7, 607, 5848, 10, 607, 12, 607, 14, 607, 5851, 11, 607, 3, 607, 3, 607, 3, 607, 3, 607, 3, 607, 3, 608, 3, 608, 3, 608, 3, 608, 7, 608, 5862, 10, 608, 12, 608, 14, 608, 5865, 11, 608, 3, 608, 3, 608, 3, 609, 6, 609, 5870, 10, 609, 13, 609, 14, 609, 5871, 3, 609, 3, 609, 3, 609, 3, 609, 7, 609, 5878, 10, 609, 12, 609, 14, 609, 5881, 11, 609, 3, 609, 3, 609, 3, 609, 7, 609, 5886, 10, 609, 12, 609, 14, 609, 5889, 11, 609, 5, 609, 5891, 10, 609, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 5898, 10, 610, 3, 611, 3, 611, 3, 612, 3, 612, 3, 613, 6, 613, 5905, 10, 613, 13, 613, 14, 613, 5906, 3, 614, 3, 614, 3, 615, 6, 615, 5912, 10, 615, 13, 615, 14, 615, 5913, 3, 615, 3, 615, 3, 615, 3, 615, 6, 615, 5920, 10, 615, 13, 615, 14, 615, 5921, 3, 615, 3, 615, 6, 615, 5926, 10, 615, 13, 615, 14, 615, 5927, 3, 615, 5, 615, 5931, 10, 615, 3, 615, 6, 615, 5934, 10, 615, 13, 615, 14, 615, 5935, 3, 615, 3, 615, 3, 615, 3, 615, 3, 615, 6, 615, 5943, 10, 615, 13, 615, 14, 615, 5944, 3, 615, 5, 615, 5948, 10, 615, 3, 615, 6, 615, 5951, 10, 615, 13, 615, 14, 615, 5952, 3, 615, 3, 615, 5, 615, 5957, 10, 615, 3, 616, 3, 616, 3, 616, 3, 617, 3, 617, 7, 617, 5964, 10, 617, 12, 617, 14, 617, 5967, 11, 617, 3, 617, 3, 617, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 5, 618, 5977, 10, 618, 3, 619, 3, 619, 5, 619, 5981, 10, 619, 3, 620, 3, 620, 5, 620, 5985, 10, 620, 3, 621, 3, 621, 3, 621, 3, 621, 3, 622, 3, 622, 3, 622, 3, 622, 7, 622, 5995, 10, 622, 12, 622, 14, 622, 5998, 11, 622, 3, 623, 3, 623, 3, 624, 3, 624, 3, 625, 5, 625, 6005, 10, 625, 3, 625, 3, 625, 3, 625, 3, 625, 7, 625, 6011, 10, 625, 12, 625, 14, 625, 6014, 11, 625, 3, 626, 3, 626, 3, 626, 3, 626, 7, 626, 6020, 10, 626, 12, 626, 14, 626, 6023, 11, 626, 3, 626, 3, 626, 3, 627, 3, 627, 3, 627, 3, 627, 7, 627, 6031, 10, 627, 12, 627, 14, 627, 6034, 11, 627, 3, 627, 6, 627, 6037, 10, 627, 13, 627, 14, 627, 6038, 3, 627, 3, 627, 3, 627, 7, 627, 6044, 10, 627, 12, 627, 14, 627, 6047, 11, 627, 3, 628, 3, 628, 5, 628, 6051, 10, 628, 3, 628, 6, 628, 6054, 10, 628, 13, 628, 14, 628, 6055, 3, 629, 3, 629, 5, 629, 6060, 10, 629, 3, 629, 3, 629, 3, 629, 3, 629, 3, 629, 3, 630, 3, 630, 7, 630, 6069, 10, 630, 12, 630, 14, 630, 6072, 11, 630, 3, 631, 3, 631, 3, 631, 3, 631, 3, 632, 3, 632, 6, 632, 6080, 10, 632, 13, 632, 14, 632, 6081, 3, 632, 3, 632, 3, 633, 3, 633, 5, 633, 6088, 10, 633, 3, 633, 5, 633, 6091, 10, 633, 3, 633, 3, 633, 3, 634, 3, 634, 3, 634, 3, 634, 3, 635, 3, 635, 3, 636, 3, 636, 3, 637, 6, 637, 6104, 10, 637, 13, 637, 14, 637, 6105, 3, 637, 3, 637, 7, 637, 6110, 10, 637, 12, 637, 14, 637, 6113, 11, 637, 5, 637, 6115, 10, 637, 3, 638, 3, 638, 5, 638, 6119, 10, 638, 3, 638, 3, 638, 3, 638, 3, 638, 3, 638, 3, 638, 3, 5849, 2, 639, 4, 3, 6, 4, 8, 5, 10, 6, 12, 7, 14, 8, 16, 9, 18, 10, 20, 11, 22, 12, 24, 13, 26, 14, 28, 15, 30, 16, 32, 17, 34, 18, 36, 19, 38, 20, 40, 21, 42, 22, 44, 23, 46, 24, 48, 25, 50, 26, 52, 27, 54, 28, 56, 29, 58, 30, 60, 31, 62, 32, 64, 33, 66, 34, 68, 35, 70, 36, 72, 37, 74, 38, 76, 39, 78, 40, 80, 41, 82, 42, 84, 43, 86, 44, 88, 45, 90, 46, 92, 47, 94, 48, 96, 49, 98, 50, 100, 51, 102, 52, 104, 53, 106, 54, 108, 55, 110, 56, 112, 57, 114, 58, 116, 59, 118, 60, 120, 61, 122, 62, 124, 63, 126, 64, 128, 65, 130, 66, 132, 67, 134, 68, 136, 69, 138, 70, 140, 71, 142, 72, 144, 73, 146, 74, 148, 75, 150, 76, 152, 77, 154, 78, 156, 79, 158, 80, 160, 81, 162, 82, 164, 83, 166, 84, 168, 85, 170, 86, 172, 87, 174, 88, 176, 89, 178, 90, 180, 91, 182, 92, 184, 93, 186, 94, 188, 95, 190, 96, 192, 97, 194, 98, 196, 99, 198, 100, 200, 101, 202, 102, 204, 103, 206, 104, 208, 105, 210, 106, 212, 107, 214, 108, 216, 109, 218, 110, 220, 111, 222, 112, 224, 113, 226, 114, 228, 115, 230, 116, 232, 117, 234, 118, 236, 119, 238, 120, 240, 121, 242, 122, 244, 123, 246, 124, 248, 125, 250, 126, 252, 127, 254, 128, 256, 129, 258, 130, 260, 131, 262, 132, 264, 133, 266, 134, 268, 135, 270, 136, 272, 137, 274, 138, 276, 139, 278, 140, 280, 141, 282, 142, 284, 143, 286, 144, 288, 145, 290, 146, 292, 147, 294, 148, 296, 149, 298, 150, 300, 151, 302, 152, 304, 153, 306, 154, 308, 155, 310, 156, 312, 157, 314, 158, 316, 159, 318, 160, 320, 161, 322, 162, 324, 163, 326, 164, 328, 165, 330, 166, 332, 167, 334, 168, 336, 169, 338, 170, 340, 171, 342, 172, 344, 173, 346, 174, 348, 175, 350, 176, 352, 177, 354, 178, 356, 179, 358, 180, 360, 181, 362, 182, 364, 183, 366, 184, 368, 185, 370, 186, 372, 187, 374, 188, 376, 189, 378, 190, 380, 191, 382, 192, 384, 193, 386, 194, 388, 195, 390, 196, 392, 197, 394, 198, 396, 199, 398, 200, 400, 201, 402, 202, 404, 203, 406, 204, 408, 205, 410, 206, 412, 207, 414, 208, 416, 209, 418, 210, 420, 211, 422, 212, 424, 213, 426, 214, 428, 215, 430, 216, 432, 217, 434, 218, 436, 219, 438, 220, 440, 221, 442, 222, 444, 223, 446, 224, 448, 225, 450, 226, 452, 227, 454, 228, 456, 229, 458, 230, 460, 231, 462, 232, 464, 233, 466, 234, 468, 235, 470, 236, 472, 237, 474, 238, 476, 239, 478, 240, 480, 241, 482, 242, 484, 243, 486, 244, 488, 245, 490, 246, 492, 247, 494, 248, 496, 249, 498, 250, 500, 251, 502, 252, 504, 253, 506, 254, 508, 255, 510, 256, 512, 257, 514, 258, 516, 259, 518, 260, 520, 261, 522, 262, 524, 263, 526, 264, 528, 265, 530, 266, 532, 267, 534, 268, 536, 269, 538, 270, 540, 271, 542, 272, 544, 273, 546, 274, 548, 275, 550, 276, 552, 277, 554, 278, 556, 279, 558, 280, 560, 281, 562, 282, 564, 283, 566, 284, 568, 285, 570, 286, 572, 287, 574, 288, 576, 289, 578, 290, 580, 291, 582, 292, 584, 293, 586, 294, 588, 295, 590, 296, 592, 297, 594, 298, 596, 299, 598, 300, 600, 301, 602, 302, 604, 303, 606, 304, 608, 305, 610, 306, 612, 307, 614, 308, 616, 309, 618, 310, 620, 311, 622, 312, 624, 313, 626, 314, 628, 315, 630, 316, 632, 317, 634, 318, 636, 319, 638, 320, 640, 321, 642, 322, 644, 323, 646, 324, 648, 325, 650, 326, 652, 327, 654, 328, 656, 329, 658, 330, 660, 331, 662, 332, 664, 333, 666, 334, 668, 335, 670, 336, 672, 337, 674, 338, 676, 339, 678, 340, 680, 341, 682, 342, 684, 343, 686, 344, 688, 345, 690, 346, 692, 347, 694, 348, 696, 349, 698, 350, 700, 351, 702, 352, 704, 353, 706, 354, 708, 355, 710, 356, 712, 357, 714, 358, 716, 359, 718, 360, 720, 361, 722, 362, 724, 363, 726, 364, 728, 365, 730, 366, 732, 367, 734, 368, 736, 369, 738, 370, 740, 371, 742, 372, 744, 373, 746, 374, 748, 375, 750, 376, 752, 377, 754, 378, 756, 379, 758, 380, 760, 381, 762, 382, 764, 383, 766, 384, 768, 385, 770, 386, 772, 387, 774, 388, 776, 389, 778, 390, 780, 391, 782, 392, 784, 393, 786, 394, 788, 395, 790, 396, 792, 397, 794, 398, 796, 399, 798, 400, 800, 401, 802, 402, 804, 403, 806, 404, 808, 405, 810, 406, 812, 407, 814, 408, 816, 409, 818, 410, 820, 411, 822, 412, 824, 413, 826, 414, 828, 415, 830, 416, 832, 417, 834, 418, 836, 419, 838, 420, 840, 421, 842, 422, 844, 423, 846, 424, 848, 425, 850, 426, 852, 427, 854, 428, 856, 429, 858, 430, 860, 431, 862, 432, 864, 433, 866, 434, 868, 435, 870, 436, 872, 437, 874, 438, 876, 439, 878, 440, 880, 441, 882, 442, 884, 443, 886, 444, 888, 445, 890, 446, 892, 447, 894, 448, 896, 449, 898, 450, 900, 451, 902, 452, 904, 453, 906, 454, 908, 455, 910, 456, 912, 457, 914, 458, 916, 459, 918, 460, 920, 461, 922, 462, 924, 463, 926, 464, 928, 465, 930, 466, 932, 467, 934, 468, 936, 469, 938, 470, 940, 471, 942, 472, 944, 473, 946, 474, 948, 475, 950, 476, 952, 477, 954, 478, 956, 479, 958, 480, 960, 481, 962, 482, 964, 483, 966, 484, 968, 485, 970, 486, 972, 487, 974, 488, 976, 489, 978, 490, 980, 491, 982, 492, 984, 493, 986, 494, 988, 495, 990, 496, 992, 497, 994, 498, 996, 499, 998, 500, 1000, 501, 1002, 502, 1004, 503, 1006, 504, 1008, 505, 1010, 506, 1012, 507, 1014, 508, 1016, 509, 1018, 510, 1020, 511, 1022, 512, 1024, 513, 1026, 514, 1028, 515, 1030, 516, 1032, 517, 1034, 518, 1036, 519, 1038, 520, 1040, 521, 1042, 522, 1044, 523, 1046, 524, 1048, 525, 1050, 526, 1052, 527, 1054, 528, 1056, 529, 1058, 530, 1060, 531, 1062, 532, 1064, 533, 1066, 534, 1068, 535, 1070, 536, 1072, 537, 1074, 538, 1076, 539, 1078, 540, 1080, 541, 1082, 542, 1084, 543, 1086, 544, 1088, 545, 1090, 546, 1092, 547, 1094, 548, 1096, 549, 1098, 550, 1100, 551, 1102, 552, 1104, 553, 1106, 554, 1108, 555, 1110, 556, 1112, 557, 1114, 558, 1116, 559, 1118, 560, 1120, 561, 1122, 562, 1124, 563, 1126, 564, 1128, 565, 1130, 566, 1132, 567, 1134, 568, 1136, 569, 1138, 570, 1140, 571, 1142, 572, 1144, 573, 1146, 574, 1148, 575, 1150, 576, 1152, 2, 1154, 577, 1156, 578, 1158, 579, 1160, 580, 1162, 581, 1164, 582, 1166, 583, 1168, 584, 1170, 585, 1172, 586, 1174, 587, 1176, 588, 1178, 589, 1180, 590, 1182, 591, 1184, 592, 1186, 593, 1188, 594, 1190, 595, 1192, 596, 1194, 597, 1196, 598, 1198, 599, 1200, 600, 1202, 601, 1204, 602, 1206, 603, 1208, 604, 1210, 605, 1212, 606, 1214, 607, 1216, 608, 1218, 609, 1220, 2, 1222, 2, 1224, 2, 1226, 610, 1228, 2, 1230, 611, 1232, 612, 1234, 613, 1236, 2, 1238, 2, 1240, 2, 1242, 614, 1244, 2, 1246, 2, 1248, 2, 1250, 615, 1252, 2, 1254, 2, 1256, 2, 1258, 616, 1260, 2, 1262, 617, 1264, 618, 1266, 619, 1268, 620, 1270, 621, 1272, 622, 1274, 623, 1276, 624, 4, 2, 3, 43, 4, 2, 67, 67, 99, 99, 4, 2, 68, 68, 100, 100, 4, 2, 81, 81, 113, 113, 4, 2, 84, 84, 116, 116, 4, 2, 86, 86, 118, 118, 4, 2, 85, 85, 117, 117, 4, 2, 78, 78, 110, 110, 4, 2, 87, 87, 119, 119, 4, 2, 71, 71, 103, 103, 4, 2, 69, 69, 101, 101, 4, 2, 75, 75, 107, 107, 4, 2, 80, 80, 112, 112, 4, 2, 70, 70, 102, 102, 4, 2, 79, 79, 111, 111, 4, 2, 72, 72, 104, 104, 4, 2, 73, 73, 105, 105, 4, 2, 89, 89, 121, 121, 4, 2, 91, 91, 123, 123, 4, 2, 74, 74, 106, 106, 4, 2, 77, 77, 109, 109, 4, 2, 82, 82, 114, 114, 4, 2, 88, 88, 120, 120, 4, 2, 90, 90, 122, 122, 4, 2, 92, 92, 124, 124, 4, 2, 76, 76, 108, 108, 4, 2, 83, 83, 115, 115, 4, 2, 12, 12, 15, 15, 4, 2, 44, 45, 62, 64, 5, 2, 44, 44, 49, 49, 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, 3, 2, 50, 59, 4, 2, 2, 2, 36, 36, 5, 2, 3, 10, 13, 14, 16, 33, 10, 2, 68, 68, 71, 71, 80, 80, 90, 90, 100, 100, 103, 103, 112, 112, 122, 122, 3, 2, 41, 41, 4, 2, 45, 45, 47, 47, 3, 2, 38, 38, 2, 6165, 2, 4, 3, 2, 2, 2, 2, 6, 3, 2, 2, 2, 2, 8, 3, 2, 2, 2, 2, 10, 3, 2, 2, 2, 2, 12, 3, 2, 2, 2, 2, 14, 3, 2, 2, 2, 2, 16, 3, 2, 2, 2, 2, 18, 3, 2, 2, 2, 2, 20, 3, 2, 2, 2, 2, 22, 3, 2, 2, 2, 2, 24, 3, 2, 2, 2, 2, 26, 3, 2, 2, 2, 2, 28, 3, 2, 2, 2, 2, 30, 3, 2, 2, 2, 2, 32, 3, 2, 2, 2, 2, 34, 3, 2, 2, 2, 2, 36, 3, 2, 2, 2, 2, 38, 3, 2, 2, 2, 2, 40, 3, 2, 2, 2, 2, 42, 3, 2, 2, 2, 2, 44, 3, 2, 2, 2, 2, 46, 3, 2, 2, 2, 2, 48, 3, 2, 2, 2, 2, 50, 3, 2, 2, 2, 2, 52, 3, 2, 2, 2, 2, 54, 3, 2, 2, 2, 2, 56, 3, 2, 2, 2, 2, 58, 3, 2, 2, 2, 2, 60, 3, 2, 2, 2, 2, 62, 3, 2, 2, 2, 2, 64, 3, 2, 2, 2, 2, 66, 3, 2, 2, 2, 2, 68, 3, 2, 2, 2, 2, 70, 3, 2, 2, 2, 2, 72, 3, 2, 2, 2, 2, 74, 3, 2, 2, 2, 2, 76, 3, 2, 2, 2, 2, 78, 3, 2, 2, 2, 2, 80, 3, 2, 2, 2, 2, 82, 3, 2, 2, 2, 2, 84, 3, 2, 2, 2, 2, 86, 3, 2, 2, 2, 2, 88, 3, 2, 2, 2, 2, 90, 3, 2, 2, 2, 2, 92, 3, 2, 2, 2, 2, 94, 3, 2, 2, 2, 2, 96, 3, 2, 2, 2, 2, 98, 3, 2, 2, 2, 2, 100, 3, 2, 2, 2, 2, 102, 3, 2, 2, 2, 2, 104, 3, 2, 2, 2, 2, 106, 3, 2, 2, 2, 2, 108, 3, 2, 2, 2, 2, 110, 3, 2, 2, 2, 2, 112, 3, 2, 2, 2, 2, 114, 3, 2, 2, 2, 2, 116, 3, 2, 2, 2, 2, 118, 3, 2, 2, 2, 2, 120, 3, 2, 2, 2, 2, 122, 3, 2, 2, 2, 2, 124, 3, 2, 2, 2, 2, 126, 3, 2, 2, 2, 2, 128, 3, 2, 2, 2, 2, 130, 3, 2, 2, 2, 2, 132, 3, 2, 2, 2, 2, 134, 3, 2, 2, 2, 2, 136, 3, 2, 2, 2, 2, 138, 3, 2, 2, 2, 2, 140, 3, 2, 2, 2, 2, 142, 3, 2, 2, 2, 2, 144, 3, 2, 2, 2, 2, 146, 3, 2, 2, 2, 2, 148, 3, 2, 2, 2, 2, 150, 3, 2, 2, 2, 2, 152, 3, 2, 2, 2, 2, 154, 3, 2, 2, 2, 2, 156, 3, 2, 2, 2, 2, 158, 3, 2, 2, 2, 2, 160, 3, 2, 2, 2, 2, 162, 3, 2, 2, 2, 2, 164, 3, 2, 2, 2, 2, 166, 3, 2, 2, 2, 2, 168, 3, 2, 2, 2, 2, 170, 3, 2, 2, 2, 2, 172, 3, 2, 2, 2, 2, 174, 3, 2, 2, 2, 2, 176, 3, 2, 2, 2, 2, 178, 3, 2, 2, 2, 2, 180, 3, 2, 2, 2, 2, 182, 3, 2, 2, 2, 2, 184, 3, 2, 2, 2, 2, 186, 3, 2, 2, 2, 2, 188, 3, 2, 2, 2, 2, 190, 3, 2, 2, 2, 2, 192, 3, 2, 2, 2, 2, 194, 3, 2, 2, 2, 2, 196, 3, 2, 2, 2, 2, 198, 3, 2, 2, 2, 2, 200, 3, 2, 2, 2, 2, 202, 3, 2, 2, 2, 2, 204, 3, 2, 2, 2, 2, 206, 3, 2, 2, 2, 2, 208, 3, 2, 2, 2, 2, 210, 3, 2, 2, 2, 2, 212, 3, 2, 2, 2, 2, 214, 3, 2, 2, 2, 2, 216, 3, 2, 2, 2, 2, 218, 3, 2, 2, 2, 2, 220, 3, 2, 2, 2, 2, 222, 3, 2, 2, 2, 2, 224, 3, 2, 2, 2, 2, 226, 3, 2, 2, 2, 2, 228, 3, 2, 2, 2, 2, 230, 3, 2, 2, 2, 2, 232, 3, 2, 2, 2, 2, 234, 3, 2, 2, 2, 2, 236, 3, 2, 2, 2, 2, 238, 3, 2, 2, 2, 2, 240, 3, 2, 2, 2, 2, 242, 3, 2, 2, 2, 2, 244, 3, 2, 2, 2, 2, 246, 3, 2, 2, 2, 2, 248, 3, 2, 2, 2, 2, 250, 3, 2, 2, 2, 2, 252, 3, 2, 2, 2, 2, 254, 3, 2, 2, 2, 2, 256, 3, 2, 2, 2, 2, 258, 3, 2, 2, 2, 2, 260, 3, 2, 2, 2, 2, 262, 3, 2, 2, 2, 2, 264, 3, 2, 2, 2, 2, 266, 3, 2, 2, 2, 2, 268, 3, 2, 2, 2, 2, 270, 3, 2, 2, 2, 2, 272, 3, 2, 2, 2, 2, 274, 3, 2, 2, 2, 2, 276, 3, 2, 2, 2, 2, 278, 3, 2, 2, 2, 2, 280, 3, 2, 2, 2, 2, 282, 3, 2, 2, 2, 2, 284, 3, 2, 2, 2, 2, 286, 3, 2, 2, 2, 2, 288, 3, 2, 2, 2, 2, 290, 3, 2, 2, 2, 2, 292, 3, 2, 2, 2, 2, 294, 3, 2, 2, 2, 2, 296, 3, 2, 2, 2, 2, 298, 3, 2, 2, 2, 2, 300, 3, 2, 2, 2, 2, 302, 3, 2, 2, 2, 2, 304, 3, 2, 2, 2, 2, 306, 3, 2, 2, 2, 2, 308, 3, 2, 2, 2, 2, 310, 3, 2, 2, 2, 2, 312, 3, 2, 2, 2, 2, 314, 3, 2, 2, 2, 2, 316, 3, 2, 2, 2, 2, 318, 3, 2, 2, 2, 2, 320, 3, 2, 2, 2, 2, 322, 3, 2, 2, 2, 2, 324, 3, 2, 2, 2, 2, 326, 3, 2, 2, 2, 2, 328, 3, 2, 2, 2, 2, 330, 3, 2, 2, 2, 2, 332, 3, 2, 2, 2, 2, 334, 3, 2, 2, 2, 2, 336, 3, 2, 2, 2, 2, 338, 3, 2, 2, 2, 2, 340, 3, 2, 2, 2, 2, 342, 3, 2, 2, 2, 2, 344, 3, 2, 2, 2, 2, 346, 3, 2, 2, 2, 2, 348, 3, 2, 2, 2, 2, 350, 3, 2, 2, 2, 2, 352, 3, 2, 2, 2, 2, 354, 3, 2, 2, 2, 2, 356, 3, 2, 2, 2, 2, 358, 3, 2, 2, 2, 2, 360, 3, 2, 2, 2, 2, 362, 3, 2, 2, 2, 2, 364, 3, 2, 2, 2, 2, 366, 3, 2, 2, 2, 2, 368, 3, 2, 2, 2, 2, 370, 3, 2, 2, 2, 2, 372, 3, 2, 2, 2, 2, 374, 3, 2, 2, 2, 2, 376, 3, 2, 2, 2, 2, 378, 3, 2, 2, 2, 2, 380, 3, 2, 2, 2, 2, 382, 3, 2, 2, 2, 2, 384, 3, 2, 2, 2, 2, 386, 3, 2, 2, 2, 2, 388, 3, 2, 2, 2, 2, 390, 3, 2, 2, 2, 2, 392, 3, 2, 2, 2, 2, 394, 3, 2, 2, 2, 2, 396, 3, 2, 2, 2, 2, 398, 3, 2, 2, 2, 2, 400, 3, 2, 2, 2, 2, 402, 3, 2, 2, 2, 2, 404, 3, 2, 2, 2, 2, 406, 3, 2, 2, 2, 2, 408, 3, 2, 2, 2, 2, 410, 3, 2, 2, 2, 2, 412, 3, 2, 2, 2, 2, 414, 3, 2, 2, 2, 2, 416, 3, 2, 2, 2, 2, 418, 3, 2, 2, 2, 2, 420, 3, 2, 2, 2, 2, 422, 3, 2, 2, 2, 2, 424, 3, 2, 2, 2, 2, 426, 3, 2, 2, 2, 2, 428, 3, 2, 2, 2, 2, 430, 3, 2, 2, 2, 2, 432, 3, 2, 2, 2, 2, 434, 3, 2, 2, 2, 2, 436, 3, 2, 2, 2, 2, 438, 3, 2, 2, 2, 2, 440, 3, 2, 2, 2, 2, 442, 3, 2, 2, 2, 2, 444, 3, 2, 2, 2, 2, 446, 3, 2, 2, 2, 2, 448, 3, 2, 2, 2, 2, 450, 3, 2, 2, 2, 2, 452, 3, 2, 2, 2, 2, 454, 3, 2, 2, 2, 2, 456, 3, 2, 2, 2, 2, 458, 3, 2, 2, 2, 2, 460, 3, 2, 2, 2, 2, 462, 3, 2, 2, 2, 2, 464, 3, 2, 2, 2, 2, 466, 3, 2, 2, 2, 2, 468, 3, 2, 2, 2, 2, 470, 3, 2, 2, 2, 2, 472, 3, 2, 2, 2, 2, 474, 3, 2, 2, 2, 2, 476, 3, 2, 2, 2, 2, 478, 3, 2, 2, 2, 2, 480, 3, 2, 2, 2, 2, 482, 3, 2, 2, 2, 2, 484, 3, 2, 2, 2, 2, 486, 3, 2, 2, 2, 2, 488, 3, 2, 2, 2, 2, 490, 3, 2, 2, 2, 2, 492, 3, 2, 2, 2, 2, 494, 3, 2, 2, 2, 2, 496, 3, 2, 2, 2, 2, 498, 3, 2, 2, 2, 2, 500, 3, 2, 2, 2, 2, 502, 3, 2, 2, 2, 2, 504, 3, 2, 2, 2, 2, 506, 3, 2, 2, 2, 2, 508, 3, 2, 2, 2, 2, 510, 3, 2, 2, 2, 2, 512, 3, 2, 2, 2, 2, 514, 3, 2, 2, 2, 2, 516, 3, 2, 2, 2, 2, 518, 3, 2, 2, 2, 2, 520, 3, 2, 2, 2, 2, 522, 3, 2, 2, 2, 2, 524, 3, 2, 2, 2, 2, 526, 3, 2, 2, 2, 2, 528, 3, 2, 2, 2, 2, 530, 3, 2, 2, 2, 2, 532, 3, 2, 2, 2, 2, 534, 3, 2, 2, 2, 2, 536, 3, 2, 2, 2, 2, 538, 3, 2, 2, 2, 2, 540, 3, 2, 2, 2, 2, 542, 3, 2, 2, 2, 2, 544, 3, 2, 2, 2, 2, 546, 3, 2, 2, 2, 2, 548, 3, 2, 2, 2, 2, 550, 3, 2, 2, 2, 2, 552, 3, 2, 2, 2, 2, 554, 3, 2, 2, 2, 2, 556, 3, 2, 2, 2, 2, 558, 3, 2, 2, 2, 2, 560, 3, 2, 2, 2, 2, 562, 3, 2, 2, 2, 2, 564, 3, 2, 2, 2, 2, 566, 3, 2, 2, 2, 2, 568, 3, 2, 2, 2, 2, 570, 3, 2, 2, 2, 2, 572, 3, 2, 2, 2, 2, 574, 3, 2, 2, 2, 2, 576, 3, 2, 2, 2, 2, 578, 3, 2, 2, 2, 2, 580, 3, 2, 2, 2, 2, 582, 3, 2, 2, 2, 2, 584, 3, 2, 2, 2, 2, 586, 3, 2, 2, 2, 2, 588, 3, 2, 2, 2, 2, 590, 3, 2, 2, 2, 2, 592, 3, 2, 2, 2, 2, 594, 3, 2, 2, 2, 2, 596, 3, 2, 2, 2, 2, 598, 3, 2, 2, 2, 2, 600, 3, 2, 2, 2, 2, 602, 3, 2, 2, 2, 2, 604, 3, 2, 2, 2, 2, 606, 3, 2, 2, 2, 2, 608, 3, 2, 2, 2, 2, 610, 3, 2, 2, 2, 2, 612, 3, 2, 2, 2, 2, 614, 3, 2, 2, 2, 2, 616, 3, 2, 2, 2, 2, 618, 3, 2, 2, 2, 2, 620, 3, 2, 2, 2, 2, 622, 3, 2, 2, 2, 2, 624, 3, 2, 2, 2, 2, 626, 3, 2, 2, 2, 2, 628, 3, 2, 2, 2, 2, 630, 3, 2, 2, 2, 2, 632, 3, 2, 2, 2, 2, 634, 3, 2, 2, 2, 2, 636, 3, 2, 2, 2, 2, 638, 3, 2, 2, 2, 2, 640, 3, 2, 2, 2, 2, 642, 3, 2, 2, 2, 2, 644, 3, 2, 2, 2, 2, 646, 3, 2, 2, 2, 2, 648, 3, 2, 2, 2, 2, 650, 3, 2, 2, 2, 2, 652, 3, 2, 2, 2, 2, 654, 3, 2, 2, 2, 2, 656, 3, 2, 2, 2, 2, 658, 3, 2, 2, 2, 2, 660, 3, 2, 2, 2, 2, 662, 3, 2, 2, 2, 2, 664, 3, 2, 2, 2, 2, 666, 3, 2, 2, 2, 2, 668, 3, 2, 2, 2, 2, 670, 3, 2, 2, 2, 2, 672, 3, 2, 2, 2, 2, 674, 3, 2, 2, 2, 2, 676, 3, 2, 2, 2, 2, 678, 3, 2, 2, 2, 2, 680, 3, 2, 2, 2, 2, 682, 3, 2, 2, 2, 2, 684, 3, 2, 2, 2, 2, 686, 3, 2, 2, 2, 2, 688, 3, 2, 2, 2, 2, 690, 3, 2, 2, 2, 2, 692, 3, 2, 2, 2, 2, 694, 3, 2, 2, 2, 2, 696, 3, 2, 2, 2, 2, 698, 3, 2, 2, 2, 2, 700, 3, 2, 2, 2, 2, 702, 3, 2, 2, 2, 2, 704, 3, 2, 2, 2, 2, 706, 3, 2, 2, 2, 2, 708, 3, 2, 2, 2, 2, 710, 3, 2, 2, 2, 2, 712, 3, 2, 2, 2, 2, 714, 3, 2, 2, 2, 2, 716, 3, 2, 2, 2, 2, 718, 3, 2, 2, 2, 2, 720, 3, 2, 2, 2, 2, 722, 3, 2, 2, 2, 2, 724, 3, 2, 2, 2, 2, 726, 3, 2, 2, 2, 2, 728, 3, 2, 2, 2, 2, 730, 3, 2, 2, 2, 2, 732, 3, 2, 2, 2, 2, 734, 3, 2, 2, 2, 2, 736, 3, 2, 2, 2, 2, 738, 3, 2, 2, 2, 2, 740, 3, 2, 2, 2, 2, 742, 3, 2, 2, 2, 2, 744, 3, 2, 2, 2, 2, 746, 3, 2, 2, 2, 2, 748, 3, 2, 2, 2, 2, 750, 3, 2, 2, 2, 2, 752, 3, 2, 2, 2, 2, 754, 3, 2, 2, 2, 2, 756, 3, 2, 2, 2, 2, 758, 3, 2, 2, 2, 2, 760, 3, 2, 2, 2, 2, 762, 3, 2, 2, 2, 2, 764, 3, 2, 2, 2, 2, 766, 3, 2, 2, 2, 2, 768, 3, 2, 2, 2, 2, 770, 3, 2, 2, 2, 2, 772, 3, 2, 2, 2, 2, 774, 3, 2, 2, 2, 2, 776, 3, 2, 2, 2, 2, 778, 3, 2, 2, 2, 2, 780, 3, 2, 2, 2, 2, 782, 3, 2, 2, 2, 2, 784, 3, 2, 2, 2, 2, 786, 3, 2, 2, 2, 2, 788, 3, 2, 2, 2, 2, 790, 3, 2, 2, 2, 2, 792, 3, 2, 2, 2, 2, 794, 3, 2, 2, 2, 2, 796, 3, 2, 2, 2, 2, 798, 3, 2, 2, 2, 2, 800, 3, 2, 2, 2, 2, 802, 3, 2, 2, 2, 2, 804, 3, 2, 2, 2, 2, 806, 3, 2, 2, 2, 2, 808, 3, 2, 2, 2, 2, 810, 3, 2, 2, 2, 2, 812, 3, 2, 2, 2, 2, 814, 3, 2, 2, 2, 2, 816, 3, 2, 2, 2, 2, 818, 3, 2, 2, 2, 2, 820, 3, 2, 2, 2, 2, 822, 3, 2, 2, 2, 2, 824, 3, 2, 2, 2, 2, 826, 3, 2, 2, 2, 2, 828, 3, 2, 2, 2, 2, 830, 3, 2, 2, 2, 2, 832, 3, 2, 2, 2, 2, 834, 3, 2, 2, 2, 2, 836, 3, 2, 2, 2, 2, 838, 3, 2, 2, 2, 2, 840, 3, 2, 2, 2, 2, 842, 3, 2, 2, 2, 2, 844, 3, 2, 2, 2, 2, 846, 3, 2, 2, 2, 2, 848, 3, 2, 2, 2, 2, 850, 3, 2, 2, 2, 2, 852, 3, 2, 2, 2, 2, 854, 3, 2, 2, 2, 2, 856, 3, 2, 2, 2, 2, 858, 3, 2, 2, 2, 2, 860, 3, 2, 2, 2, 2, 862, 3, 2, 2, 2, 2, 864, 3, 2, 2, 2, 2, 866, 3, 2, 2, 2, 2, 868, 3, 2, 2, 2, 2, 870, 3, 2, 2, 2, 2, 872, 3, 2, 2, 2, 2, 874, 3, 2, 2, 2, 2, 876, 3, 2, 2, 2, 2, 878, 3, 2, 2, 2, 2, 880, 3, 2, 2, 2, 2, 882, 3, 2, 2, 2, 2, 884, 3, 2, 2, 2, 2, 886, 3, 2, 2, 2, 2, 888, 3, 2, 2, 2, 2, 890, 3, 2, 2, 2, 2, 892, 3, 2, 2, 2, 2, 894, 3, 2, 2, 2, 2, 896, 3, 2, 2, 2, 2, 898, 3, 2, 2, 2, 2, 900, 3, 2, 2, 2, 2, 902, 3, 2, 2, 2, 2, 904, 3, 2, 2, 2, 2, 906, 3, 2, 2, 2, 2, 908, 3, 2, 2, 2, 2, 910, 3, 2, 2, 2, 2, 912, 3, 2, 2, 2, 2, 914, 3, 2, 2, 2, 2, 916, 3, 2, 2, 2, 2, 918, 3, 2, 2, 2, 2, 920, 3, 2, 2, 2, 2, 922, 3, 2, 2, 2, 2, 924, 3, 2, 2, 2, 2, 926, 3, 2, 2, 2, 2, 928, 3, 2, 2, 2, 2, 930, 3, 2, 2, 2, 2, 932, 3, 2, 2, 2, 2, 934, 3, 2, 2, 2, 2, 936, 3, 2, 2, 2, 2, 938, 3, 2, 2, 2, 2, 940, 3, 2, 2, 2, 2, 942, 3, 2, 2, 2, 2, 944, 3, 2, 2, 2, 2, 946, 3, 2, 2, 2, 2, 948, 3, 2, 2, 2, 2, 950, 3, 2, 2, 2, 2, 952, 3, 2, 2, 2, 2, 954, 3, 2, 2, 2, 2, 956, 3, 2, 2, 2, 2, 958, 3, 2, 2, 2, 2, 960, 3, 2, 2, 2, 2, 962, 3, 2, 2, 2, 2, 964, 3, 2, 2, 2, 2, 966, 3, 2, 2, 2, 2, 968, 3, 2, 2, 2, 2, 970, 3, 2, 2, 2, 2, 972, 3, 2, 2, 2, 2, 974, 3, 2, 2, 2, 2, 976, 3, 2, 2, 2, 2, 978, 3, 2, 2, 2, 2, 980, 3, 2, 2, 2, 2, 982, 3, 2, 2, 2, 2, 984, 3, 2, 2, 2, 2, 986, 3, 2, 2, 2, 2, 988, 3, 2, 2, 2, 2, 990, 3, 2, 2, 2, 2, 992, 3, 2, 2, 2, 2, 994, 3, 2, 2, 2, 2, 996, 3, 2, 2, 2, 2, 998, 3, 2, 2, 2, 2, 1000, 3, 2, 2, 2, 2, 1002, 3, 2, 2, 2, 2, 1004, 3, 2, 2, 2, 2, 1006, 3, 2, 2, 2, 2, 1008, 3, 2, 2, 2, 2, 1010, 3, 2, 2, 2, 2, 1012, 3, 2, 2, 2, 2, 1014, 3, 2, 2, 2, 2, 1016, 3, 2, 2, 2, 2, 1018, 3, 2, 2, 2, 2, 1020, 3, 2, 2, 2, 2, 1022, 3, 2, 2, 2, 2, 1024, 3, 2, 2, 2, 2, 1026, 3, 2, 2, 2, 2, 1028, 3, 2, 2, 2, 2, 1030, 3, 2, 2, 2, 2, 1032, 3, 2, 2, 2, 2, 1034, 3, 2, 2, 2, 2, 1036, 3, 2, 2, 2, 2, 1038, 3, 2, 2, 2, 2, 1040, 3, 2, 2, 2, 2, 1042, 3, 2, 2, 2, 2, 1044, 3, 2, 2, 2, 2, 1046, 3, 2, 2, 2, 2, 1048, 3, 2, 2, 2, 2, 1050, 3, 2, 2, 2, 2, 1052, 3, 2, 2, 2, 2, 1054, 3, 2, 2, 2, 2, 1056, 3, 2, 2, 2, 2, 1058, 3, 2, 2, 2, 2, 1060, 3, 2, 2, 2, 2, 1062, 3, 2, 2, 2, 2, 1064, 3, 2, 2, 2, 2, 1066, 3, 2, 2, 2, 2, 1068, 3, 2, 2, 2, 2, 1070, 3, 2, 2, 2, 2, 1072, 3, 2, 2, 2, 2, 1074, 3, 2, 2, 2, 2, 1076, 3, 2, 2, 2, 2, 1078, 3, 2, 2, 2, 2, 1080, 3, 2, 2, 2, 2, 1082, 3, 2, 2, 2, 2, 1084, 3, 2, 2, 2, 2, 1086, 3, 2, 2, 2, 2, 1088, 3, 2, 2, 2, 2, 1090, 3, 2, 2, 2, 2, 1092, 3, 2, 2, 2, 2, 1094, 3, 2, 2, 2, 2, 1096, 3, 2, 2, 2, 2, 1098, 3, 2, 2, 2, 2, 1100, 3, 2, 2, 2, 2, 1102, 3, 2, 2, 2, 2, 1104, 3, 2, 2, 2, 2, 1106, 3, 2, 2, 2, 2, 1108, 3, 2, 2, 2, 2, 1110, 3, 2, 2, 2, 2, 1112, 3, 2, 2, 2, 2, 1114, 3, 2, 2, 2, 2, 1116, 3, 2, 2, 2, 2, 1118, 3, 2, 2, 2, 2, 1120, 3, 2, 2, 2, 2, 1122, 3, 2, 2, 2, 2, 1124, 3, 2, 2, 2, 2, 1126, 3, 2, 2, 2, 2, 1128, 3, 2, 2, 2, 2, 1130, 3, 2, 2, 2, 2, 1132, 3, 2, 2, 2, 2, 1134, 3, 2, 2, 2, 2, 1136, 3, 2, 2, 2, 2, 1138, 3, 2, 2, 2, 2, 1140, 3, 2, 2, 2, 2, 1142, 3, 2, 2, 2, 2, 1144, 3, 2, 2, 2, 2, 1146, 3, 2, 2, 2, 2, 1148, 3, 2, 2, 2, 2, 1150, 3, 2, 2, 2, 2, 1154, 3, 2, 2, 2, 2, 1156, 3, 2, 2, 2, 2, 1158, 3, 2, 2, 2, 2, 1160, 3, 2, 2, 2, 2, 1162, 3, 2, 2, 2, 2, 1164, 3, 2, 2, 2, 2, 1166, 3, 2, 2, 2, 2, 1168, 3, 2, 2, 2, 2, 1170, 3, 2, 2, 2, 2, 1172, 3, 2, 2, 2, 2, 1174, 3, 2, 2, 2, 2, 1176, 3, 2, 2, 2, 2, 1178, 3, 2, 2, 2, 2, 1180, 3, 2, 2, 2, 2, 1182, 3, 2, 2, 2, 2, 1184, 3, 2, 2, 2, 2, 1186, 3, 2, 2, 2, 2, 1188, 3, 2, 2, 2, 2, 1190, 3, 2, 2, 2, 2, 1192, 3, 2, 2, 2, 2, 1194, 3, 2, 2, 2, 2, 1196, 3, 2, 2, 2, 2, 1198, 3, 2, 2, 2, 2, 1200, 3, 2, 2, 2, 2, 1202, 3, 2, 2, 2, 2, 1204, 3, 2, 2, 2, 2, 1206, 3, 2, 2, 2, 2, 1208, 3, 2, 2, 2, 2, 1210, 3, 2, 2, 2, 2, 1212, 3, 2, 2, 2, 2, 1214, 3, 2, 2, 2, 2, 1216, 3, 2, 2, 2, 2, 1218, 3, 2, 2, 2, 2, 1226, 3, 2, 2, 2, 2, 1230, 3, 2, 2, 2, 2, 1232, 3, 2, 2, 2, 2, 1234, 3, 2, 2, 2, 2, 1242, 3, 2, 2, 2, 2, 1250, 3, 2, 2, 2, 2, 1258, 3, 2, 2, 2, 2, 1262, 3, 2, 2, 2, 2, 1264, 3, 2, 2, 2, 2, 1266, 3, 2, 2, 2, 2, 1268, 3, 2, 2, 2, 2, 1270, 3, 2, 2, 2, 2, 1272, 3, 2, 2, 2, 3, 1274, 3, 2, 2, 2, 3, 1276, 3, 2, 2, 2, 4, 1278, 3, 2, 2, 2, 6, 1284, 3, 2, 2, 2, 8, 1293, 3, 2, 2, 2, 10, 1300, 3, 2, 2, 2, 12, 1307, 3, 2, 2, 2, 14, 1311, 3, 2, 2, 2, 16, 1317, 3, 2, 2, 2, 18, 1323, 3, 2, 2, 2, 20, 1333, 3, 2, 2, 2, 22, 1338, 3, 2, 2, 2, 24, 1344, 3, 2, 2, 2, 26, 1351, 3, 2, 2, 2, 28, 1361, 3, 2, 2, 2, 30, 1372, 3, 2, 2, 2, 32, 1375, 3, 2, 2, 2, 34, 1382, 3, 2, 2, 2, 36, 1392, 3, 2, 2, 2, 38, 1401, 3, 2, 2, 2, 40, 1408, 3, 2, 2, 2, 42, 1414, 3, 2, 2, 2, 44, 1417, 3, 2, 2, 2, 46, 1423, 3, 2, 2, 2, 48, 1428, 3, 2, 2, 2, 50, 1435, 3, 2, 2, 2, 52, 1443, 3, 2, 2, 2, 54, 1452, 3, 2, 2, 2, 56, 1460, 3, 2, 2, 2, 58, 1466, 3, 2, 2, 2, 60, 1482, 3, 2, 2, 2, 62, 1493, 3, 2, 2, 2, 64, 1499, 3, 2, 2, 2, 66, 1505, 3, 2, 2, 2, 68, 1513, 3, 2, 2, 2, 70, 1521, 3, 2, 2, 2, 72, 1529, 3, 2, 2, 2, 74, 1538, 3, 2, 2, 2, 76, 1545, 3, 2, 2, 2, 78, 1555, 3, 2, 2, 2, 80, 1569, 3, 2, 2, 2, 82, 1578, 3, 2, 2, 2, 84, 1589, 3, 2, 2, 2, 86, 1601, 3, 2, 2, 2, 88, 1609, 3, 2, 2, 2, 90, 1618, 3, 2, 2, 2, 92, 1629, 3, 2, 2, 2, 94, 1634, 3, 2, 2, 2, 96, 1639, 3, 2, 2, 2, 98, 1643, 3, 2, 2, 2, 100, 1648, 3, 2, 2, 2, 102, 1656, 3, 2, 2, 2, 104, 1663, 3, 2, 2, 2, 106, 1669, 3, 2, 2, 2, 108, 1674, 3, 2, 2, 2, 110, 1683, 3, 2, 2, 2, 112, 1687, 3, 2, 2, 2, 114, 1698, 3, 2, 2, 2, 116, 1706, 3, 2, 2, 2, 118, 1715, 3, 2, 2, 2, 120, 1724, 3, 2, 2, 2, 122, 1732, 3, 2, 2, 2, 124, 1739, 3, 2, 2, 2, 126, 1749, 3, 2, 2, 2, 128, 1760, 3, 2, 2, 2, 130, 1768, 3, 2, 2, 2, 132, 1775, 3, 2, 2, 2, 134, 1786, 3, 2, 2, 2, 136, 1794, 3, 2, 2, 2, 138, 1802, 3, 2, 2, 2, 140, 1811, 3, 2, 2, 2, 142, 1818, 3, 2, 2, 2, 144, 1825, 3, 2, 2, 2, 146, 1830, 3, 2, 2, 2, 148, 1835, 3, 2, 2, 2, 150, 1842, 3, 2, 2, 2, 152, 1851, 3, 2, 2, 2, 154, 1861, 3, 2, 2, 2, 156, 1866, 3, 2, 2, 2, 158, 1873, 3, 2, 2, 2, 160, 1879, 3, 2, 2, 2, 162, 1887, 3, 2, 2, 2, 164, 1897, 3, 2, 2, 2, 166, 1907, 3, 2, 2, 2, 168, 1915, 3, 2, 2, 2, 170, 1923, 3, 2, 2, 2, 172, 1933, 3, 2, 2, 2, 174, 1942, 3, 2, 2, 2, 176, 1949, 3, 2, 2, 2, 178, 1956, 3, 2, 2, 2, 180, 1962, 3, 2, 2, 2, 182, 1972, 3, 2, 2, 2, 184, 1978, 3, 2, 2, 2, 186, 1986, 3, 2, 2, 2, 188, 1995, 3, 2, 2, 2, 190, 2005, 3, 2, 2, 2, 192, 2015, 3, 2, 2, 2, 194, 2022, 3, 2, 2, 2, 196, 2030, 3, 2, 2, 2, 198, 2037, 3, 2, 2, 2, 200, 2045, 3, 2, 2, 2, 202, 2052, 3, 2, 2, 2, 204, 2057, 3, 2, 2, 2, 206, 2062, 3, 2, 2, 2, 208, 2071, 3, 2, 2, 2, 210, 2074, 3, 2, 2, 2, 212, 2084, 3, 2, 2, 2, 214, 2094, 3, 2, 2, 2, 216, 2103, 3, 2, 2, 2, 218, 2110, 3, 2, 2, 2, 220, 2118, 3, 2, 2, 2, 222, 2128, 3, 2, 2, 2, 224, 2138, 3, 2, 2, 2, 226, 2144, 3, 2, 2, 2, 228, 2152, 3, 2, 2, 2, 230, 2160, 3, 2, 2, 2, 232, 2169, 3, 2, 2, 2, 234, 2176, 3, 2, 2, 2, 236, 2182, 3, 2, 2, 2, 238, 2194, 3, 2, 2, 2, 240, 2201, 3, 2, 2, 2, 242, 2209, 3, 2, 2, 2, 244, 2217, 3, 2, 2, 2, 246, 2227, 3, 2, 2, 2, 248, 2231, 3, 2, 2, 2, 250, 2237, 3, 2, 2, 2, 252, 2246, 3, 2, 2, 2, 254, 2252, 3, 2, 2, 2, 256, 2257, 3, 2, 2, 2, 258, 2267, 3, 2, 2, 2, 260, 2273, 3, 2, 2, 2, 262, 2280, 3, 2, 2, 2, 264, 2285, 3, 2, 2, 2, 266, 2291, 3, 2, 2, 2, 268, 2300, 3, 2, 2, 2, 270, 2305, 3, 2, 2, 2, 272, 2312, 3, 2, 2, 2, 274, 2319, 3, 2, 2, 2, 276, 2327, 3, 2, 2, 2, 278, 2333, 3, 2, 2, 2, 280, 2346, 3, 2, 2, 2, 282, 2355, 3, 2, 2, 2, 284, 2362, 3, 2, 2, 2, 286, 2369, 3, 2, 2, 2, 288, 2378, 3, 2, 2, 2, 290, 2383, 3, 2, 2, 2, 292, 2389, 3, 2, 2, 2, 294, 2394, 3, 2, 2, 2, 296, 2399, 3, 2, 2, 2, 298, 2405, 3, 2, 2, 2, 300, 2409, 3, 2, 2, 2, 302, 2414, 3, 2, 2, 2, 304, 2417, 3, 2, 2, 2, 306, 2425, 3, 2, 2, 2, 308, 2432, 3, 2, 2, 2, 310, 2439, 3, 2, 2, 2, 312, 2445, 3, 2, 2, 2, 314, 2452, 3, 2, 2, 2, 316, 2455, 3, 2, 2, 2, 318, 2459, 3, 2, 2, 2, 320, 2464, 3, 2, 2, 2, 322, 2468, 3, 2, 2, 2, 324, 2477, 3, 2, 2, 2, 326, 2484, 3, 2, 2, 2, 328, 2492, 3, 2, 2, 2, 330, 2503, 3, 2, 2, 2, 332, 2510, 3, 2, 2, 2, 334, 2515, 3, 2, 2, 2, 336, 2526, 3, 2, 2, 2, 338, 2532, 3, 2, 2, 2, 340, 2538, 3, 2, 2, 2, 342, 2547, 3, 2, 2, 2, 344, 2554, 3, 2, 2, 2, 346, 2562, 3, 2, 2, 2, 348, 2572, 3, 2, 2, 2, 350, 2580, 3, 2, 2, 2, 352, 2589, 3, 2, 2, 2, 354, 2595, 3, 2, 2, 2, 356, 2602, 3, 2, 2, 2, 358, 2612, 3, 2, 2, 2, 360, 2620, 3, 2, 2, 2, 362, 2629, 3, 2, 2, 2, 364, 2638, 3, 2, 2, 2, 366, 2644, 3, 2, 2, 2, 368, 2655, 3, 2, 2, 2, 370, 2666, 3, 2, 2, 2, 372, 2676, 3, 2, 2, 2, 374, 2687, 3, 2, 2, 2, 376, 2695, 3, 2, 2, 2, 378, 2707, 3, 2, 2, 2, 380, 2713, 3, 2, 2, 2, 382, 2719, 3, 2, 2, 2, 384, 2724, 3, 2, 2, 2, 386, 2733, 3, 2, 2, 2, 388, 2741, 3, 2, 2, 2, 390, 2751, 3, 2, 2, 2, 392, 2755, 3, 2, 2, 2, 394, 2767, 3, 2, 2, 2, 396, 2775, 3, 2, 2, 2, 398, 2783, 3, 2, 2, 2, 400, 2792, 3, 2, 2, 2, 402, 2800, 3, 2, 2, 2, 404, 2807, 3, 2, 2, 2, 406, 2818, 3, 2, 2, 2, 408, 2826, 3, 2, 2, 2, 410, 2834, 3, 2, 2, 2, 412, 2840, 3, 2, 2, 2, 414, 2848, 3, 2, 2, 2, 416, 2857, 3, 2, 2, 2, 418, 2865, 3, 2, 2, 2, 420, 2872, 3, 2, 2, 2, 422, 2877, 3, 2, 2, 2, 424, 2886, 3, 2, 2, 2, 426, 2893, 3, 2, 2, 2, 428, 2901, 3, 2, 2, 2, 430, 2910, 3, 2, 2, 2, 432, 2915, 3, 2, 2, 2, 434, 2920, 3, 2, 2, 2, 436, 2930, 3, 2, 2, 2, 438, 2937, 3, 2, 2, 2, 440, 2945, 3, 2, 2, 2, 442, 2952, 3, 2, 2, 2, 444, 2959, 3, 2, 2, 2, 446, 2966, 3, 2, 2, 2, 448, 2975, 3, 2, 2, 2, 450, 2984, 3, 2, 2, 2, 452, 2994, 3, 2, 2, 2, 454, 3007, 3, 2, 2, 2, 456, 3014, 3, 2, 2, 2, 458, 3022, 3, 2, 2, 2, 460, 3026, 3, 2, 2, 2, 462, 3031, 3, 2, 2, 2, 464, 3037, 3, 2, 2, 2, 466, 3042, 3, 2, 2, 2, 468, 3049, 3, 2, 2, 2, 470, 3054, 3, 2, 2, 2, 472, 3063, 3, 2, 2, 2, 474, 3067, 3, 2, 2, 2, 476, 3074, 3, 2, 2, 2, 478, 3085, 3, 2, 2, 2, 480, 3091, 3, 2, 2, 2, 482, 3101, 3, 2, 2, 2, 484, 3112, 3, 2, 2, 2, 486, 3118, 3, 2, 2, 2, 488, 3125, 3, 2, 2, 2, 490, 3133, 3, 2, 2, 2, 492, 3140, 3, 2, 2, 2, 494, 3147, 3, 2, 2, 2, 496, 3153, 3, 2, 2, 2, 498, 3166, 3, 2, 2, 2, 500, 3174, 3, 2, 2, 2, 502, 3180, 3, 2, 2, 2, 504, 3187, 3, 2, 2, 2, 506, 3194, 3, 2, 2, 2, 508, 3205, 3, 2, 2, 2, 510, 3210, 3, 2, 2, 2, 512, 3219, 3, 2, 2, 2, 514, 3229, 3, 2, 2, 2, 516, 3234, 3, 2, 2, 2, 518, 3239, 3, 2, 2, 2, 520, 3251, 3, 2, 2, 2, 522, 3261, 3, 2, 2, 2, 524, 3269, 3, 2, 2, 2, 526, 3278, 3, 2, 2, 2, 528, 3286, 3, 2, 2, 2, 530, 3291, 3, 2, 2, 2, 532, 3297, 3, 2, 2, 2, 534, 3307, 3, 2, 2, 2, 536, 3319, 3, 2, 2, 2, 538, 3331, 3, 2, 2, 2, 540, 3339, 3, 2, 2, 2, 542, 3348, 3, 2, 2, 2, 544, 3357, 3, 2, 2, 2, 546, 3363, 3, 2, 2, 2, 548, 3370, 3, 2, 2, 2, 550, 3377, 3, 2, 2, 2, 552, 3383, 3, 2, 2, 2, 554, 3392, 3, 2, 2, 2, 556, 3402, 3, 2, 2, 2, 558, 3408, 3, 2, 2, 2, 560, 3416, 3, 2, 2, 2, 562, 3424, 3, 2, 2, 2, 564, 3429, 3, 2, 2, 2, 566, 3435, 3, 2, 2, 2, 568, 3444, 3, 2, 2, 2, 570, 3455, 3, 2, 2, 2, 572, 3462, 3, 2, 2, 2, 574, 3470, 3, 2, 2, 2, 576, 3475, 3, 2, 2, 2, 578, 3483, 3, 2, 2, 2, 580, 3489, 3, 2, 2, 2, 582, 3493, 3, 2, 2, 2, 584, 3498, 3, 2, 2, 2, 586, 3502, 3, 2, 2, 2, 588, 3507, 3, 2, 2, 2, 590, 3515, 3, 2, 2, 2, 592, 3522, 3, 2, 2, 2, 594, 3526, 3, 2, 2, 2, 596, 3534, 3, 2, 2, 2, 598, 3539, 3, 2, 2, 2, 600, 3549, 3, 2, 2, 2, 602, 3558, 3, 2, 2, 2, 604, 3562, 3, 2, 2, 2, 606, 3570, 3, 2, 2, 2, 608, 3577, 3, 2, 2, 2, 610, 3585, 3, 2, 2, 2, 612, 3591, 3, 2, 2, 2, 614, 3600, 3, 2, 2, 2, 616, 3609, 3, 2, 2, 2, 618, 3615, 3, 2, 2, 2, 620, 3619, 3, 2, 2, 2, 622, 3627, 3, 2, 2, 2, 624, 3636, 3, 2, 2, 2, 626, 3642, 3, 2, 2, 2, 628, 3651, 3, 2, 2, 2, 630, 3657, 3, 2, 2, 2, 632, 3662, 3, 2, 2, 2, 634, 3669, 3, 2, 2, 2, 636, 3677, 3, 2, 2, 2, 638, 3681, 3, 2, 2, 2, 640, 3689, 3, 2, 2, 2, 642, 3698, 3, 2, 2, 2, 644, 3708, 3, 2, 2, 2, 646, 3713, 3, 2, 2, 2, 648, 3717, 3, 2, 2, 2, 650, 3723, 3, 2, 2, 2, 652, 3732, 3, 2, 2, 2, 654, 3742, 3, 2, 2, 2, 656, 3747, 3, 2, 2, 2, 658, 3757, 3, 2, 2, 2, 660, 3763, 3, 2, 2, 2, 662, 3768, 3, 2, 2, 2, 664, 3775, 3, 2, 2, 2, 666, 3783, 3, 2, 2, 2, 668, 3797, 3, 2, 2, 2, 670, 3807, 3, 2, 2, 2, 672, 3818, 3, 2, 2, 2, 674, 3828, 3, 2, 2, 2, 676, 3838, 3, 2, 2, 2, 678, 3852, 3, 2, 2, 2, 680, 3861, 3, 2, 2, 2, 682, 3867, 3, 2, 2, 2, 684, 3875, 3, 2, 2, 2, 686, 3888, 3, 2, 2, 2, 688, 3897, 3, 2, 2, 2, 690, 3911, 3, 2, 2, 2, 692, 3918, 3, 2, 2, 2, 694, 3928, 3, 2, 2, 2, 696, 3941, 3, 2, 2, 2, 698, 3947, 3, 2, 2, 2, 700, 3962, 3, 2, 2, 2, 702, 3969, 3, 2, 2, 2, 704, 3974, 3, 2, 2, 2, 706, 3980, 3, 2, 2, 2, 708, 3986, 3, 2, 2, 2, 710, 3989, 3, 2, 2, 2, 712, 3996, 3, 2, 2, 2, 714, 4001, 3, 2, 2, 2, 716, 4006, 3, 2, 2, 2, 718, 4011, 3, 2, 2, 2, 720, 4019, 3, 2, 2, 2, 722, 4027, 3, 2, 2, 2, 724, 4033, 3, 2, 2, 2, 726, 4042, 3, 2, 2, 2, 728, 4048, 3, 2, 2, 2, 730, 4056, 3, 2, 2, 2, 732, 4068, 3, 2, 2, 2, 734, 4076, 3, 2, 2, 2, 736, 4080, 3, 2, 2, 2, 738, 4088, 3, 2, 2, 2, 740, 4096, 3, 2, 2, 2, 742, 4100, 3, 2, 2, 2, 744, 4104, 3, 2, 2, 2, 746, 4110, 3, 2, 2, 2, 748, 4113, 3, 2, 2, 2, 750, 4117, 3, 2, 2, 2, 752, 4128, 3, 2, 2, 2, 754, 4133, 3, 2, 2, 2, 756, 4138, 3, 2, 2, 2, 758, 4143, 3, 2, 2, 2, 760, 4149, 3, 2, 2, 2, 762, 4157, 3, 2, 2, 2, 764, 4164, 3, 2, 2, 2, 766, 4175, 3, 2, 2, 2, 768, 4182, 3, 2, 2, 2, 770, 4198, 3, 2, 2, 2, 772, 4211, 3, 2, 2, 2, 774, 4224, 3, 2, 2, 2, 776, 4237, 3, 2, 2, 2, 778, 4255, 3, 2, 2, 2, 780, 4268, 3, 2, 2, 2, 782, 4276, 3, 2, 2, 2, 784, 4287, 3, 2, 2, 2, 786, 4292, 3, 2, 2, 2, 788, 4301, 3, 2, 2, 2, 790, 4304, 3, 2, 2, 2, 792, 4309, 3, 2, 2, 2, 794, 4313, 3, 2, 2, 2, 796, 4320, 3, 2, 2, 2, 798, 4326, 3, 2, 2, 2, 800, 4332, 3, 2, 2, 2, 802, 4336, 3, 2, 2, 2, 804, 4344, 3, 2, 2, 2, 806, 4349, 3, 2, 2, 2, 808, 4355, 3, 2, 2, 2, 810, 4361, 3, 2, 2, 2, 812, 4368, 3, 2, 2, 2, 814, 4371, 3, 2, 2, 2, 816, 4381, 3, 2, 2, 2, 818, 4391, 3, 2, 2, 2, 820, 4396, 3, 2, 2, 2, 822, 4404, 3, 2, 2, 2, 824, 4412, 3, 2, 2, 2, 826, 4418, 3, 2, 2, 2, 828, 4428, 3, 2, 2, 2, 830, 4443, 3, 2, 2, 2, 832, 4447, 3, 2, 2, 2, 834, 4452, 3, 2, 2, 2, 836, 4459, 3, 2, 2, 2, 838, 4462, 3, 2, 2, 2, 840, 4467, 3, 2, 2, 2, 842, 4470, 3, 2, 2, 2, 844, 4476, 3, 2, 2, 2, 846, 4484, 3, 2, 2, 2, 848, 4492, 3, 2, 2, 2, 850, 4503, 3, 2, 2, 2, 852, 4513, 3, 2, 2, 2, 854, 4520, 3, 2, 2, 2, 856, 4533, 3, 2, 2, 2, 858, 4538, 3, 2, 2, 2, 860, 4548, 3, 2, 2, 2, 862, 4554, 3, 2, 2, 2, 864, 4559, 3, 2, 2, 2, 866, 4562, 3, 2, 2, 2, 868, 4571, 3, 2, 2, 2, 870, 4576, 3, 2, 2, 2, 872, 4582, 3, 2, 2, 2, 874, 4589, 3, 2, 2, 2, 876, 4594, 3, 2, 2, 2, 878, 4600, 3, 2, 2, 2, 880, 4609, 3, 2, 2, 2, 882, 4614, 3, 2, 2, 2, 884, 4620, 3, 2, 2, 2, 886, 4627, 3, 2, 2, 2, 888, 4632, 3, 2, 2, 2, 890, 4642, 3, 2, 2, 2, 892, 4651, 3, 2, 2, 2, 894, 4659, 3, 2, 2, 2, 896, 4669, 3, 2, 2, 2, 898, 4679, 3, 2, 2, 2, 900, 4688, 3, 2, 2, 2, 902, 4699, 3, 2, 2, 2, 904, 4711, 3, 2, 2, 2, 906, 4722, 3, 2, 2, 2, 908, 4730, 3, 2, 2, 2, 910, 4736, 3, 2, 2, 2, 912, 4745, 3, 2, 2, 2, 914, 4756, 3, 2, 2, 2, 916, 4769, 3, 2, 2, 2, 918, 4783, 3, 2, 2, 2, 920, 4799, 3, 2, 2, 2, 922, 4807, 3, 2, 2, 2, 924, 4816, 3, 2, 2, 2, 926, 4826, 3, 2, 2, 2, 928, 4834, 3, 2, 2, 2, 930, 4843, 3, 2, 2, 2, 932, 4858, 3, 2, 2, 2, 934, 4869, 3, 2, 2, 2, 936, 4881, 3, 2, 2, 2, 938, 4888, 3, 2, 2, 2, 940, 4897, 3, 2, 2, 2, 942, 4902, 3, 2, 2, 2, 944, 4909, 3, 2, 2, 2, 946, 4918, 3, 2, 2, 2, 948, 4931, 3, 2, 2, 2, 950, 4945, 3, 2, 2, 2, 952, 4950, 3, 2, 2, 2, 954, 4959, 3, 2, 2, 2, 956, 4974, 3, 2, 2, 2, 958, 4979, 3, 2, 2, 2, 960, 4990, 3, 2, 2, 2, 962, 4999, 3, 2, 2, 2, 964, 5007, 3, 2, 2, 2, 966, 5014, 3, 2, 2, 2, 968, 5023, 3, 2, 2, 2, 970, 5028, 3, 2, 2, 2, 972, 5035, 3, 2, 2, 2, 974, 5041, 3, 2, 2, 2, 976, 5046, 3, 2, 2, 2, 978, 5053, 3, 2, 2, 2, 980, 5064, 3, 2, 2, 2, 982, 5072, 3, 2, 2, 2, 984, 5081, 3, 2, 2, 2, 986, 5091, 3, 2, 2, 2, 988, 5100, 3, 2, 2, 2, 990, 5108, 3, 2, 2, 2, 992, 5115, 3, 2, 2, 2, 994, 5123, 3, 2, 2, 2, 996, 5130, 3, 2, 2, 2, 998, 5138, 3, 2, 2, 2, 1000, 5150, 3, 2, 2, 2, 1002, 5161, 3, 2, 2, 2, 1004, 5174, 3, 2, 2, 2, 1006, 5184, 3, 2, 2, 2, 1008, 5192, 3, 2, 2, 2, 1010, 5206, 3, 2, 2, 2, 1012, 5218, 3, 2, 2, 2, 1014, 5225, 3, 2, 2, 2, 1016, 5239, 3, 2, 2, 2, 1018, 5244, 3, 2, 2, 2, 1020, 5255, 3, 2, 2, 2, 1022, 5261, 3, 2, 2, 2, 1024, 5271, 3, 2, 2, 2, 1026, 5280, 3, 2, 2, 2, 1028, 5284, 3, 2, 2, 2, 1030, 5288, 3, 2, 2, 2, 1032, 5296, 3, 2, 2, 2, 1034, 5306, 3, 2, 2, 2, 1036, 5318, 3, 2, 2, 2, 1038, 5329, 3, 2, 2, 2, 1040, 5341, 3, 2, 2, 2, 1042, 5350, 3, 2, 2, 2, 1044, 5355, 3, 2, 2, 2, 1046, 5360, 3, 2, 2, 2, 1048, 5371, 3, 2, 2, 2, 1050, 5380, 3, 2, 2, 2, 1052, 5386, 3, 2, 2, 2, 1054, 5396, 3, 2, 2, 2, 1056, 5408, 3, 2, 2, 2, 1058, 5415, 3, 2, 2, 2, 1060, 5422, 3, 2, 2, 2, 1062, 5428, 3, 2, 2, 2, 1064, 5441, 3, 2, 2, 2, 1066, 5457, 3, 2, 2, 2, 1068, 5465, 3, 2, 2, 2, 1070, 5473, 3, 2, 2, 2, 1072, 5483, 3, 2, 2, 2, 1074, 5490, 3, 2, 2, 2, 1076, 5500, 3, 2, 2, 2, 1078, 5511, 3, 2, 2, 2, 1080, 5518, 3, 2, 2, 2, 1082, 5524, 3, 2, 2, 2, 1084, 5533, 3, 2, 2, 2, 1086, 5538, 3, 2, 2, 2, 1088, 5544, 3, 2, 2, 2, 1090, 5551, 3, 2, 2, 2, 1092, 5560, 3, 2, 2, 2, 1094, 5569, 3, 2, 2, 2, 1096, 5575, 3, 2, 2, 2, 1098, 5582, 3, 2, 2, 2, 1100, 5594, 3, 2, 2, 2, 1102, 5601, 3, 2, 2, 2, 1104, 5607, 3, 2, 2, 2, 1106, 5615, 3, 2, 2, 2, 1108, 5620, 3, 2, 2, 2, 1110, 5630, 3, 2, 2, 2, 1112, 5638, 3, 2, 2, 2, 1114, 5642, 3, 2, 2, 2, 1116, 5647, 3, 2, 2, 2, 1118, 5652, 3, 2, 2, 2, 1120, 5656, 3, 2, 2, 2, 1122, 5661, 3, 2, 2, 2, 1124, 5669, 3, 2, 2, 2, 1126, 5676, 3, 2, 2, 2, 1128, 5681, 3, 2, 2, 2, 1130, 5689, 3, 2, 2, 2, 1132, 5695, 3, 2, 2, 2, 1134, 5701, 3, 2, 2, 2, 1136, 5708, 3, 2, 2, 2, 1138, 5715, 3, 2, 2, 2, 1140, 5723, 3, 2, 2, 2, 1142, 5731, 3, 2, 2, 2, 1144, 5737, 3, 2, 2, 2, 1146, 5746, 3, 2, 2, 2, 1148, 5754, 3, 2, 2, 2, 1150, 5762, 3, 2, 2, 2, 1152, 5768, 3, 2, 2, 2, 1154, 5770, 3, 2, 2, 2, 1156, 5773, 3, 2, 2, 2, 1158, 5775, 3, 2, 2, 2, 1160, 5777, 3, 2, 2, 2, 1162, 5779, 3, 2, 2, 2, 1164, 5785, 3, 2, 2, 2, 1166, 5787, 3, 2, 2, 2, 1168, 5789, 3, 2, 2, 2, 1170, 5792, 3, 2, 2, 2, 1172, 5794, 3, 2, 2, 2, 1174, 5797, 3, 2, 2, 2, 1176, 5799, 3, 2, 2, 2, 1178, 5801, 3, 2, 2, 2, 1180, 5803, 3, 2, 2, 2, 1182, 5805, 3, 2, 2, 2, 1184, 5807, 3, 2, 2, 2, 1186, 5809, 3, 2, 2, 2, 1188, 5811, 3, 2, 2, 2, 1190, 5813, 3, 2, 2, 2, 1192, 5815, 3, 2, 2, 2, 1194, 5817, 3, 2, 2, 2, 1196, 5819, 3, 2, 2, 2, 1198, 5821, 3, 2, 2, 2, 1200, 5823, 3, 2, 2, 2, 1202, 5825, 3, 2, 2, 2, 1204, 5828, 3, 2, 2, 2, 1206, 5831, 3, 2, 2, 2, 1208, 5834, 3, 2, 2, 2, 1210, 5837, 3, 2, 2, 2, 1212, 5840, 3, 2, 2, 2, 1214, 5842, 3, 2, 2, 2, 1216, 5857, 3, 2, 2, 2, 1218, 5890, 3, 2, 2, 2, 1220, 5897, 3, 2, 2, 2, 1222, 5899, 3, 2, 2, 2, 1224, 5901, 3, 2, 2, 2, 1226, 5904, 3, 2, 2, 2, 1228, 5908, 3, 2, 2, 2, 1230, 5956, 3, 2, 2, 2, 1232, 5958, 3, 2, 2, 2, 1234, 5961, 3, 2, 2, 2, 1236, 5976, 3, 2, 2, 2, 1238, 5980, 3, 2, 2, 2, 1240, 5984, 3, 2, 2, 2, 1242, 5986, 3, 2, 2, 2, 1244, 5990, 3, 2, 2, 2, 1246, 5999, 3, 2, 2, 2, 1248, 6001, 3, 2, 2, 2, 1250, 6004, 3, 2, 2, 2, 1252, 6015, 3, 2, 2, 2, 1254, 6036, 3, 2, 2, 2, 1256, 6048, 3, 2, 2, 2, 1258, 6057, 3, 2, 2, 2, 1260, 6066, 3, 2, 2, 2, 1262, 6073, 3, 2, 2, 2, 1264, 6079, 3, 2, 2, 2, 1266, 6090, 3, 2, 2, 2, 1268, 6094, 3, 2, 2, 2, 1270, 6098, 3, 2, 2, 2, 1272, 6100, 3, 2, 2, 2, 1274, 6114, 3, 2, 2, 2, 1276, 6116, 3, 2, 2, 2, 1278, 1279, 9, 2, 2, 2, 1279, 1280, 9, 3, 2, 2, 1280, 1281, 9, 4, 2, 2, 1281, 1282, 9, 5, 2, 2, 1282, 1283, 9, 6, 2, 2, 1283, 5, 3, 2, 2, 2, 1284, 1285, 9, 2, 2, 2, 1285, 1286, 9, 3, 2, 2, 1286, 1287, 9, 7, 2, 2, 1287, 1288, 9, 4, 2, 2, 1288, 1289, 9, 8, 2, 2, 1289, 1290, 9, 9, 2, 2, 1290, 1291, 9, 6, 2, 2, 1291, 1292, 9, 10, 2, 2, 1292, 7, 3, 2, 2, 2, 1293, 1294, 9, 2, 2, 2, 1294, 1295, 9, 11, 2, 2, 1295, 1296, 9, 11, 2, 2, 1296, 1297, 9, 10, 2, 2, 1297, 1298, 9, 7, 2, 2, 1298, 1299, 9, 7, 2, 2, 1299, 9, 3, 2, 2, 2, 1300, 1301, 9, 2, 2, 2, 1301, 1302, 9, 11, 2, 2, 1302, 1303, 9, 6, 2, 2, 1303, 1304, 9, 12, 2, 2, 1304, 1305, 9, 4, 2, 2, 1305, 1306, 9, 13, 2, 2, 1306, 11, 3, 2, 2, 2, 1307, 1308, 9, 2, 2, 2, 1308, 1309, 9, 14, 2, 2, 1309, 1310, 9, 14, 2, 2, 1310, 13, 3, 2, 2, 2, 1311, 1312, 9, 2, 2, 2, 1312, 1313, 9, 14, 2, 2, 1313, 1314, 9, 15, 2, 2, 1314, 1315, 9, 12, 2, 2, 1315, 1316, 9, 13, 2, 2, 1316, 15, 3, 2, 2, 2, 1317, 1318, 9, 2, 2, 2, 1318, 1319, 9, 16, 2, 2, 1319, 1320, 9, 6, 2, 2, 1320, 1321, 9, 10, 2, 2, 1321, 1322, 9, 5, 2, 2, 1322, 17, 3, 2, 2, 2, 1323, 1324, 9, 2, 2, 2, 1324, 1325, 9, 17, 2, 2, 1325, 1326, 9, 17, 2, 2, 1326, 1327, 9, 5, 2, 2, 1327, 1328, 9, 10, 2, 2, 1328, 1329, 9, 17, 2, 2, 1329, 1330, 9, 2, 2, 2, 1330, 1331, 9, 6, 2, 2, 1331, 1332, 9, 10, 2, 2, 1332, 19, 3, 2, 2, 2, 1333, 1334, 9, 2, 2, 2, 1334, 1335, 9, 8, 2, 2, 1335, 1336, 9, 7, 2, 2, 1336, 1337, 9, 4, 2, 2, 1337, 21, 3, 2, 2, 2, 1338, 1339, 9, 2, 2, 2, 1339, 1340, 9, 8, 2, 2, 1340, 1341, 9, 6, 2, 2, 1341, 1342, 9, 10, 2, 2, 1342, 1343, 9, 5, 2, 2, 1343, 23, 3, 2, 2, 2, 1344, 1345, 9, 2, 2, 2, 1345, 1346, 9, 8, 2, 2, 1346, 1347, 9, 18, 2, 2, 1347, 1348, 9, 2, 2, 2, 1348, 1349, 9, 19, 2, 2, 1349, 1350, 9, 7, 2, 2, 1350, 25, 3, 2, 2, 2, 1351, 1352, 9, 2, 2, 2, 1352, 1353, 9, 7, 2, 2, 1353, 1354, 9, 7, 2, 2, 1354, 1355, 9, 10, 2, 2, 1355, 1356, 9, 5, 2, 2, 1356, 1357, 9, 6, 2, 2, 1357, 1358, 9, 12, 2, 2, 1358, 1359, 9, 4, 2, 2, 1359, 1360, 9, 13, 2, 2, 1360, 27, 3, 2, 2, 2, 1361, 1362, 9, 2, 2, 2, 1362, 1363, 9, 7, 2, 2, 1363, 1364, 9, 7, 2, 2, 1364, 1365, 9, 12, 2, 2, 1365, 1366, 9, 17, 2, 2, 1366, 1367, 9, 13, 2, 2, 1367, 1368, 9, 15, 2, 2, 1368, 1369, 9, 10, 2, 2, 1369, 1370, 9, 13, 2, 2, 1370, 1371, 9, 6, 2, 2, 1371, 29, 3, 2, 2, 2, 1372, 1373, 9, 2, 2, 2, 1373, 1374, 9, 6, 2, 2, 1374, 31, 3, 2, 2, 2, 1375, 1376, 9, 2, 2, 2, 1376, 1377, 9, 6, 2, 2, 1377, 1378, 9, 6, 2, 2, 1378, 1379, 9, 2, 2, 2, 1379, 1380, 9, 11, 2, 2, 1380, 1381, 9, 20, 2, 2, 1381, 33, 3, 2, 2, 2, 1382, 1383, 9, 2, 2, 2, 1383, 1384, 9, 6, 2, 2, 1384, 1385, 9, 6, 2, 2, 1385, 1386, 9, 5, 2, 2, 1386, 1387, 9, 12, 2, 2, 1387, 1388, 9, 3, 2, 2, 1388, 1389, 9, 9, 2, 2, 1389, 1390, 9, 6, 2, 2, 1390, 1391, 9, 10, 2, 2, 1391, 35, 3, 2, 2, 2, 1392, 1393, 9, 3, 2, 2, 1393, 1394, 9, 2, 2, 2, 1394, 1395, 9, 11, 2, 2, 1395, 1396, 9, 21, 2, 2, 1396, 1397, 9, 18, 2, 2, 1397, 1398, 9, 2, 2, 2, 1398, 1399, 9, 5, 2, 2, 1399, 1400, 9, 14, 2, 2, 1400, 37, 3, 2, 2, 2, 1401, 1402, 9, 3, 2, 2, 1402, 1403, 9, 10, 2, 2, 1403, 1404, 9, 16, 2, 2, 1404, 1405, 9, 4, 2, 2, 1405, 1406, 9, 5, 2, 2, 1406, 1407, 9, 10, 2, 2, 1407, 39, 3, 2, 2, 2, 1408, 1409, 9, 3, 2, 2, 1409, 1410, 9, 10, 2, 2, 1410, 1411, 9, 17, 2, 2, 1411, 1412, 9, 12, 2, 2, 1412, 1413, 9, 13, 2, 2, 1413, 41, 3, 2, 2, 2, 1414, 1415, 9, 3, 2, 2, 1415, 1416, 9, 19, 2, 2, 1416, 43, 3, 2, 2, 2, 1417, 1418, 9, 11, 2, 2, 1418, 1419, 9, 2, 2, 2, 1419, 1420, 9, 11, 2, 2, 1420, 1421, 9, 20, 2, 2, 1421, 1422, 9, 10, 2, 2, 1422, 45, 3, 2, 2, 2, 1423, 1424, 9, 11, 2, 2, 1424, 1425, 9, 2, 2, 2, 1425, 1426, 9, 8, 2, 2, 1426, 1427, 9, 8, 2, 2, 1427, 47, 3, 2, 2, 2, 1428, 1429, 9, 11, 2, 2, 1429, 1430, 9, 2, 2, 2, 1430, 1431, 9, 8, 2, 2, 1431, 1432, 9, 8, 2, 2, 1432, 1433, 9, 10, 2, 2, 1433, 1434, 9, 14, 2, 2, 1434, 49, 3, 2, 2, 2, 1435, 1436, 9, 11, 2, 2, 1436, 1437, 9, 2, 2, 2, 1437, 1438, 9, 7, 2, 2, 1438, 1439, 9, 11, 2, 2, 1439, 1440, 9, 2, 2, 2, 1440, 1441, 9, 14, 2, 2, 1441, 1442, 9, 10, 2, 2, 1442, 51, 3, 2, 2, 2, 1443, 1444, 9, 11, 2, 2, 1444, 1445, 9, 2, 2, 2, 1445, 1446, 9, 7, 2, 2, 1446, 1447, 9, 11, 2, 2, 1447, 1448, 9, 2, 2, 2, 1448, 1449, 9, 14, 2, 2, 1449, 1450, 9, 10, 2, 2, 1450, 1451, 9, 14, 2, 2, 1451, 53, 3, 2, 2, 2, 1452, 1453, 9, 11, 2, 2, 1453, 1454, 9, 2, 2, 2, 1454, 1455, 9, 6, 2, 2, 1455, 1456, 9, 2, 2, 2, 1456, 1457, 9, 8, 2, 2, 1457, 1458, 9, 4, 2, 2, 1458, 1459, 9, 17, 2, 2, 1459, 55, 3, 2, 2, 2, 1460, 1461, 9, 11, 2, 2, 1461, 1462, 9, 20, 2, 2, 1462, 1463, 9, 2, 2, 2, 1463, 1464, 9, 12, 2, 2, 1464, 1465, 9, 13, 2, 2, 1465, 57, 3, 2, 2, 2, 1466, 1467, 9, 11, 2, 2, 1467, 1468, 9, 20, 2, 2, 1468, 1469, 9, 2, 2, 2, 1469, 1470, 9, 5, 2, 2, 1470, 1471, 9, 2, 2, 2, 1471, 1472, 9, 11, 2, 2, 1472, 1473, 9, 6, 2, 2, 1473, 1474, 9, 10, 2, 2, 1474, 1475, 9, 5, 2, 2, 1475, 1476, 9, 12, 2, 2, 1476, 1477, 9, 7, 2, 2, 1477, 1478, 9, 6, 2, 2, 1478, 1479, 9, 12, 2, 2, 1479, 1480, 9, 11, 2, 2, 1480, 1481, 9, 7, 2, 2, 1481, 59, 3, 2, 2, 2, 1482, 1483, 9, 11, 2, 2, 1483, 1484, 9, 20, 2, 2, 1484, 1485, 9, 10, 2, 2, 1485, 1486, 9, 11, 2, 2, 1486, 1487, 9, 21, 2, 2, 1487, 1488, 9, 22, 2, 2, 1488, 1489, 9, 4, 2, 2, 1489, 1490, 9, 12, 2, 2, 1490, 1491, 9, 13, 2, 2, 1491, 1492, 9, 6, 2, 2, 1492, 61, 3, 2, 2, 2, 1493, 1494, 9, 11, 2, 2, 1494, 1495, 9, 8, 2, 2, 1495, 1496, 9, 2, 2, 2, 1496, 1497, 9, 7, 2, 2, 1497, 1498, 9, 7, 2, 2, 1498, 63, 3, 2, 2, 2, 1499, 1500, 9, 11, 2, 2, 1500, 1501, 9, 8, 2, 2, 1501, 1502, 9, 4, 2, 2, 1502, 1503, 9, 7, 2, 2, 1503, 1504, 9, 10, 2, 2, 1504, 65, 3, 2, 2, 2, 1505, 1506, 9, 11, 2, 2, 1506, 1507, 9, 8, 2, 2, 1507, 1508, 9, 9, 2, 2, 1508, 1509, 9, 7, 2, 2, 1509, 1510, 9, 6, 2, 2, 1510, 1511, 9, 10, 2, 2, 1511, 1512, 9, 5, 2, 2, 1512, 67, 3, 2, 2, 2, 1513, 1514, 9, 11, 2, 2, 1514, 1515, 9, 4, 2, 2, 1515, 1516, 9, 8, 2, 2, 1516, 1517, 9, 9, 2, 2, 1517, 1518, 9, 15, 2, 2, 1518, 1519, 9, 13, 2, 2, 1519, 1520, 9, 7, 2, 2, 1520, 69, 3, 2, 2, 2, 1521, 1522, 9, 11, 2, 2, 1522, 1523, 9, 4, 2, 2, 1523, 1524, 9, 15, 2, 2, 1524, 1525, 9, 15, 2, 2, 1525, 1526, 9, 10, 2, 2, 1526, 1527, 9, 13, 2, 2, 1527, 1528, 9, 6, 2, 2, 1528, 71, 3, 2, 2, 2, 1529, 1530, 9, 11, 2, 2, 1530, 1531, 9, 4, 2, 2, 1531, 1532, 9, 15, 2, 2, 1532, 1533, 9, 15, 2, 2, 1533, 1534, 9, 10, 2, 2, 1534, 1535, 9, 13, 2, 2, 1535, 1536, 9, 6, 2, 2, 1536, 1537, 9, 7, 2, 2, 1537, 73, 3, 2, 2, 2, 1538, 1539, 9, 11, 2, 2, 1539, 1540, 9, 4, 2, 2, 1540, 1541, 9, 15, 2, 2, 1541, 1542, 9, 15, 2, 2, 1542, 1543, 9, 12, 2, 2, 1543, 1544, 9, 6, 2, 2, 1544, 75, 3, 2, 2, 2, 1545, 1546, 9, 11, 2, 2, 1546, 1547, 9, 4, 2, 2, 1547, 1548, 9, 15, 2, 2, 1548, 1549, 9, 15, 2, 2, 1549, 1550, 9, 12, 2, 2, 1550, 1551, 9, 6, 2, 2, 1551, 1552, 9, 6, 2, 2, 1552, 1553, 9, 10, 2, 2, 1553, 1554, 9, 14, 2, 2, 1554, 77, 3, 2, 2, 2, 1555, 1556, 9, 11, 2, 2, 1556, 1557, 9, 4, 2, 2, 1557, 1558, 9, 13, 2, 2, 1558, 1559, 9, 16, 2, 2, 1559, 1560, 9, 12, 2, 2, 1560, 1561, 9, 17, 2, 2, 1561, 1562, 9, 9, 2, 2, 1562, 1563, 9, 5, 2, 2, 1563, 1564, 9, 2, 2, 2, 1564, 1565, 9, 6, 2, 2, 1565, 1566, 9, 12, 2, 2, 1566, 1567, 9, 4, 2, 2, 1567, 1568, 9, 13, 2, 2, 1568, 79, 3, 2, 2, 2, 1569, 1570, 9, 11, 2, 2, 1570, 1571, 9, 4, 2, 2, 1571, 1572, 9, 13, 2, 2, 1572, 1573, 9, 16, 2, 2, 1573, 1574, 9, 8, 2, 2, 1574, 1575, 9, 12, 2, 2, 1575, 1576, 9, 11, 2, 2, 1576, 1577, 9, 6, 2, 2, 1577, 81, 3, 2, 2, 2, 1578, 1579, 9, 11, 2, 2, 1579, 1580, 9, 4, 2, 2, 1580, 1581, 9, 13, 2, 2, 1581, 1582, 9, 13, 2, 2, 1582, 1583, 9, 10, 2, 2, 1583, 1584, 9, 11, 2, 2, 1584, 1585, 9, 6, 2, 2, 1585, 1586, 9, 12, 2, 2, 1586, 1587, 9, 4, 2, 2, 1587, 1588, 9, 13, 2, 2, 1588, 83, 3, 2, 2, 2, 1589, 1590, 9, 11, 2, 2, 1590, 1591, 9, 4, 2, 2, 1591, 1592, 9, 13, 2, 2, 1592, 1593, 9, 7, 2, 2, 1593, 1594, 9, 6, 2, 2, 1594, 1595, 9, 5, 2, 2, 1595, 1596, 9, 2, 2, 2, 1596, 1597, 9, 12, 2, 2, 1597, 1598, 9, 13, 2, 2, 1598, 1599, 9, 6, 2, 2, 1599, 1600, 9, 7, 2, 2, 1600, 85, 3, 2, 2, 2, 1601, 1602, 9, 11, 2, 2, 1602, 1603, 9, 4, 2, 2, 1603, 1604, 9, 13, 2, 2, 1604, 1605, 9, 6, 2, 2, 1605, 1606, 9, 10, 2, 2, 1606, 1607, 9, 13, 2, 2, 1607, 1608, 9, 6, 2, 2, 1608, 87, 3, 2, 2, 2, 1609, 1610, 9, 11, 2, 2, 1610, 1611, 9, 4, 2, 2, 1611, 1612, 9, 13, 2, 2, 1612, 1613, 9, 6, 2, 2, 1613, 1614, 9, 12, 2, 2, 1614, 1615, 9, 13, 2, 2, 1615, 1616, 9, 9, 2, 2, 1616, 1617, 9, 10, 2, 2, 1617, 89, 3, 2, 2, 2, 1618, 1619, 9, 11, 2, 2, 1619, 1620, 9, 4, 2, 2, 1620, 1621, 9, 13, 2, 2, 1621, 1622, 9, 23, 2, 2, 1622, 1623, 9, 10, 2, 2, 1623, 1624, 9, 5, 2, 2, 1624, 1625, 9, 7, 2, 2, 1625, 1626, 9, 12, 2, 2, 1626, 1627, 9, 4, 2, 2, 1627, 1628, 9, 13, 2, 2, 1628, 91, 3, 2, 2, 2, 1629, 1630, 9, 11, 2, 2, 1630, 1631, 9, 4, 2, 2, 1631, 1632, 9, 22, 2, 2, 1632, 1633, 9, 19, 2, 2, 1633, 93, 3, 2, 2, 2, 1634, 1635, 9, 11, 2, 2, 1635, 1636, 9, 4, 2, 2, 1636, 1637, 9, 7, 2, 2, 1637, 1638, 9, 6, 2, 2, 1638, 95, 3, 2, 2, 2, 1639, 1640, 9, 11, 2, 2, 1640, 1641, 9, 7, 2, 2, 1641, 1642, 9, 23, 2, 2, 1642, 97, 3, 2, 2, 2, 1643, 1644, 9, 11, 2, 2, 1644, 1645, 9, 9, 2, 2, 1645, 1646, 9, 3, 2, 2, 1646, 1647, 9, 10, 2, 2, 1647, 99, 3, 2, 2, 2, 1648, 1649, 9, 11, 2, 2, 1649, 1650, 9, 9, 2, 2, 1650, 1651, 9, 5, 2, 2, 1651, 1652, 9, 5, 2, 2, 1652, 1653, 9, 10, 2, 2, 1653, 1654, 9, 13, 2, 2, 1654, 1655, 9, 6, 2, 2, 1655, 101, 3, 2, 2, 2, 1656, 1657, 9, 11, 2, 2, 1657, 1658, 9, 9, 2, 2, 1658, 1659, 9, 5, 2, 2, 1659, 1660, 9, 7, 2, 2, 1660, 1661, 9, 4, 2, 2, 1661, 1662, 9, 5, 2, 2, 1662, 103, 3, 2, 2, 2, 1663, 1664, 9, 11, 2, 2, 1664, 1665, 9, 19, 2, 2, 1665, 1666, 9, 11, 2, 2, 1666, 1667, 9, 8, 2, 2, 1667, 1668, 9, 10, 2, 2, 1668, 105, 3, 2, 2, 2, 1669, 1670, 9, 14, 2, 2, 1670, 1671, 9, 2, 2, 2, 1671, 1672, 9, 6, 2, 2, 1672, 1673, 9, 2, 2, 2, 1673, 107, 3, 2, 2, 2, 1674, 1675, 9, 14, 2, 2, 1675, 1676, 9, 2, 2, 2, 1676, 1677, 9, 6, 2, 2, 1677, 1678, 9, 2, 2, 2, 1678, 1679, 9, 3, 2, 2, 1679, 1680, 9, 2, 2, 2, 1680, 1681, 9, 7, 2, 2, 1681, 1682, 9, 10, 2, 2, 1682, 109, 3, 2, 2, 2, 1683, 1684, 9, 14, 2, 2, 1684, 1685, 9, 2, 2, 2, 1685, 1686, 9, 19, 2, 2, 1686, 111, 3, 2, 2, 2, 1687, 1688, 9, 14, 2, 2, 1688, 1689, 9, 10, 2, 2, 1689, 1690, 9, 2, 2, 2, 1690, 1691, 9, 8, 2, 2, 1691, 1692, 9, 8, 2, 2, 1692, 1693, 9, 4, 2, 2, 1693, 1694, 9, 11, 2, 2, 1694, 1695, 9, 2, 2, 2, 1695, 1696, 9, 6, 2, 2, 1696, 1697, 9, 10, 2, 2, 1697, 113, 3, 2, 2, 2, 1698, 1699, 9, 14, 2, 2, 1699, 1700, 9, 10, 2, 2, 1700, 1701, 9, 11, 2, 2, 1701, 1702, 9, 8, 2, 2, 1702, 1703, 9, 2, 2, 2, 1703, 1704, 9, 5, 2, 2, 1704, 1705, 9, 10, 2, 2, 1705, 115, 3, 2, 2, 2, 1706, 1707, 9, 14, 2, 2, 1707, 1708, 9, 10, 2, 2, 1708, 1709, 9, 16, 2, 2, 1709, 1710, 9, 2, 2, 2, 1710, 1711, 9, 9, 2, 2, 1711, 1712, 9, 8, 2, 2, 1712, 1713, 9, 6, 2, 2, 1713, 1714, 9, 7, 2, 2, 1714, 117, 3, 2, 2, 2, 1715, 1716, 9, 14, 2, 2, 1716, 1717, 9, 10, 2, 2, 1717, 1718, 9, 16, 2, 2, 1718, 1719, 9, 10, 2, 2, 1719, 1720, 9, 5, 2, 2, 1720, 1721, 9, 5, 2, 2, 1721, 1722, 9, 10, 2, 2, 1722, 1723, 9, 14, 2, 2, 1723, 119, 3, 2, 2, 2, 1724, 1725, 9, 14, 2, 2, 1725, 1726, 9, 10, 2, 2, 1726, 1727, 9, 16, 2, 2, 1727, 1728, 9, 12, 2, 2, 1728, 1729, 9, 13, 2, 2, 1729, 1730, 9, 10, 2, 2, 1730, 1731, 9, 5, 2, 2, 1731, 121, 3, 2, 2, 2, 1732, 1733, 9, 14, 2, 2, 1733, 1734, 9, 10, 2, 2, 1734, 1735, 9, 8, 2, 2, 1735, 1736, 9, 10, 2, 2, 1736, 1737, 9, 6, 2, 2, 1737, 1738, 9, 10, 2, 2, 1738, 123, 3, 2, 2, 2, 1739, 1740, 9, 14, 2, 2, 1740, 1741, 9, 10, 2, 2, 1741, 1742, 9, 8, 2, 2, 1742, 1743, 9, 12, 2, 2, 1743, 1744, 9, 15, 2, 2, 1744, 1745, 9, 12, 2, 2, 1745, 1746, 9, 6, 2, 2, 1746, 1747, 9, 10, 2, 2, 1747, 1748, 9, 5, 2, 2, 1748, 125, 3, 2, 2, 2, 1749, 1750, 9, 14, 2, 2, 1750, 1751, 9, 10, 2, 2, 1751, 1752, 9, 8, 2, 2, 1752, 1753, 9, 12, 2, 2, 1753, 1754, 9, 15, 2, 2, 1754, 1755, 9, 12, 2, 2, 1755, 1756, 9, 6, 2, 2, 1756, 1757, 9, 10, 2, 2, 1757, 1758, 9, 5, 2, 2, 1758, 1759, 9, 7, 2, 2, 1759, 127, 3, 2, 2, 2, 1760, 1761, 9, 14, 2, 2, 1761, 1762, 9, 10, 2, 2, 1762, 1763, 9, 22, 2, 2, 1763, 1764, 9, 10, 2, 2, 1764, 1765, 9, 13, 2, 2, 1765, 1766, 9, 14, 2, 2, 1766, 1767, 9, 7, 2, 2, 1767, 129, 3, 2, 2, 2, 1768, 1769, 9, 14, 2, 2, 1769, 1770, 9, 10, 2, 2, 1770, 1771, 9, 6, 2, 2, 1771, 1772, 9, 2, 2, 2, 1772, 1773, 9, 11, 2, 2, 1773, 1774, 9, 20, 2, 2, 1774, 131, 3, 2, 2, 2, 1775, 1776, 9, 14, 2, 2, 1776, 1777, 9, 12, 2, 2, 1777, 1778, 9, 11, 2, 2, 1778, 1779, 9, 6, 2, 2, 1779, 1780, 9, 12, 2, 2, 1780, 1781, 9, 4, 2, 2, 1781, 1782, 9, 13, 2, 2, 1782, 1783, 9, 2, 2, 2, 1783, 1784, 9, 5, 2, 2, 1784, 1785, 9, 19, 2, 2, 1785, 133, 3, 2, 2, 2, 1786, 1787, 9, 14, 2, 2, 1787, 1788, 9, 12, 2, 2, 1788, 1789, 9, 7, 2, 2, 1789, 1790, 9, 2, 2, 2, 1790, 1791, 9, 3, 2, 2, 1791, 1792, 9, 8, 2, 2, 1792, 1793, 9, 10, 2, 2, 1793, 135, 3, 2, 2, 2, 1794, 1795, 9, 14, 2, 2, 1795, 1796, 9, 12, 2, 2, 1796, 1797, 9, 7, 2, 2, 1797, 1798, 9, 11, 2, 2, 1798, 1799, 9, 2, 2, 2, 1799, 1800, 9, 5, 2, 2, 1800, 1801, 9, 14, 2, 2, 1801, 137, 3, 2, 2, 2, 1802, 1803, 9, 14, 2, 2, 1803, 1804, 9, 4, 2, 2, 1804, 1805, 9, 11, 2, 2, 1805, 1806, 9, 9, 2, 2, 1806, 1807, 9, 15, 2, 2, 1807, 1808, 9, 10, 2, 2, 1808, 1809, 9, 13, 2, 2, 1809, 1810, 9, 6, 2, 2, 1810, 139, 3, 2, 2, 2, 1811, 1812, 9, 14, 2, 2, 1812, 1813, 9, 4, 2, 2, 1813, 1814, 9, 15, 2, 2, 1814, 1815, 9, 2, 2, 2, 1815, 1816, 9, 12, 2, 2, 1816, 1817, 9, 13, 2, 2, 1817, 141, 3, 2, 2, 2, 1818, 1819, 9, 14, 2, 2, 1819, 1820, 9, 4, 2, 2, 1820, 1821, 9, 9, 2, 2, 1821, 1822, 9, 3, 2, 2, 1822, 1823, 9, 8, 2, 2, 1823, 1824, 9, 10, 2, 2, 1824, 143, 3, 2, 2, 2, 1825, 1826, 9, 14, 2, 2, 1826, 1827, 9, 5, 2, 2, 1827, 1828, 9, 4, 2, 2, 1828, 1829, 9, 22, 2, 2, 1829, 145, 3, 2, 2, 2, 1830, 1831, 9, 10, 2, 2, 1831, 1832, 9, 2, 2, 2, 1832, 1833, 9, 11, 2, 2, 1833, 1834, 9, 20, 2, 2, 1834, 147, 3, 2, 2, 2, 1835, 1836, 9, 10, 2, 2, 1836, 1837, 9, 13, 2, 2, 1837, 1838, 9, 2, 2, 2, 1838, 1839, 9, 3, 2, 2, 1839, 1840, 9, 8, 2, 2, 1840, 1841, 9, 10, 2, 2, 1841, 149, 3, 2, 2, 2, 1842, 1843, 9, 10, 2, 2, 1843, 1844, 9, 13, 2, 2, 1844, 1845, 9, 11, 2, 2, 1845, 1846, 9, 4, 2, 2, 1846, 1847, 9, 14, 2, 2, 1847, 1848, 9, 12, 2, 2, 1848, 1849, 9, 13, 2, 2, 1849, 1850, 9, 17, 2, 2, 1850, 151, 3, 2, 2, 2, 1851, 1852, 9, 10, 2, 2, 1852, 1853, 9, 13, 2, 2, 1853, 1854, 9, 11, 2, 2, 1854, 1855, 9, 5, 2, 2, 1855, 1856, 9, 19, 2, 2, 1856, 1857, 9, 22, 2, 2, 1857, 1858, 9, 6, 2, 2, 1858, 1859, 9, 10, 2, 2, 1859, 1860, 9, 14, 2, 2, 1860, 153, 3, 2, 2, 2, 1861, 1862, 9, 10, 2, 2, 1862, 1863, 9, 13, 2, 2, 1863, 1864, 9, 9, 2, 2, 1864, 1865, 9, 15, 2, 2, 1865, 155, 3, 2, 2, 2, 1866, 1867, 9, 10, 2, 2, 1867, 1868, 9, 7, 2, 2, 1868, 1869, 9, 11, 2, 2, 1869, 1870, 9, 2, 2, 2, 1870, 1871, 9, 22, 2, 2, 1871, 1872, 9, 10, 2, 2, 1872, 157, 3, 2, 2, 2, 1873, 1874, 9, 10, 2, 2, 1874, 1875, 9, 23, 2, 2, 1875, 1876, 9, 10, 2, 2, 1876, 1877, 9, 13, 2, 2, 1877, 1878, 9, 6, 2, 2, 1878, 159, 3, 2, 2, 2, 1879, 1880, 9, 10, 2, 2, 1880, 1881, 9, 24, 2, 2, 1881, 1882, 9, 11, 2, 2, 1882, 1883, 9, 8, 2, 2, 1883, 1884, 9, 9, 2, 2, 1884, 1885, 9, 14, 2, 2, 1885, 1886, 9, 10, 2, 2, 1886, 161, 3, 2, 2, 2, 1887, 1888, 9, 10, 2, 2, 1888, 1889, 9, 24, 2, 2, 1889, 1890, 9, 11, 2, 2, 1890, 1891, 9, 8, 2, 2, 1891, 1892, 9, 9, 2, 2, 1892, 1893, 9, 14, 2, 2, 1893, 1894, 9, 12, 2, 2, 1894, 1895, 9, 13, 2, 2, 1895, 1896, 9, 17, 2, 2, 1896, 163, 3, 2, 2, 2, 1897, 1898, 9, 10, 2, 2, 1898, 1899, 9, 24, 2, 2, 1899, 1900, 9, 11, 2, 2, 1900, 1901, 9, 8, 2, 2, 1901, 1902, 9, 9, 2, 2, 1902, 1903, 9, 7, 2, 2, 1903, 1904, 9, 12, 2, 2, 1904, 1905, 9, 23, 2, 2, 1905, 1906, 9, 10, 2, 2, 1906, 165, 3, 2, 2, 2, 1907, 1908, 9, 10, 2, 2, 1908, 1909, 9, 24, 2, 2, 1909, 1910, 9, 10, 2, 2, 1910, 1911, 9, 11, 2, 2, 1911, 1912, 9, 9, 2, 2, 1912, 1913, 9, 6, 2, 2, 1913, 1914, 9, 10, 2, 2, 1914, 167, 3, 2, 2, 2, 1915, 1916, 9, 10, 2, 2, 1916, 1917, 9, 24, 2, 2, 1917, 1918, 9, 22, 2, 2, 1918, 1919, 9, 8, 2, 2, 1919, 1920, 9, 2, 2, 2, 1920, 1921, 9, 12, 2, 2, 1921, 1922, 9, 13, 2, 2, 1922, 169, 3, 2, 2, 2, 1923, 1924, 9, 10, 2, 2, 1924, 1925, 9, 24, 2, 2, 1925, 1926, 9, 6, 2, 2, 1926, 1927, 9, 10, 2, 2, 1927, 1928, 9, 13, 2, 2, 1928, 1929, 9, 7, 2, 2, 1929, 1930, 9, 12, 2, 2, 1930, 1931, 9, 4, 2, 2, 1931, 1932, 9, 13, 2, 2, 1932, 171, 3, 2, 2, 2, 1933, 1934, 9, 10, 2, 2, 1934, 1935, 9, 24, 2, 2, 1935, 1936, 9, 6, 2, 2, 1936, 1937, 9, 10, 2, 2, 1937, 1938, 9, 5, 2, 2, 1938, 1939, 9, 13, 2, 2, 1939, 1940, 9, 2, 2, 2, 1940, 1941, 9, 8, 2, 2, 1941, 173, 3, 2, 2, 2, 1942, 1943, 9, 16, 2, 2, 1943, 1944, 9, 2, 2, 2, 1944, 1945, 9, 15, 2, 2, 1945, 1946, 9, 12, 2, 2, 1946, 1947, 9, 8, 2, 2, 1947, 1948, 9, 19, 2, 2, 1948, 175, 3, 2, 2, 2, 1949, 1950, 9, 16, 2, 2, 1950, 1951, 9, 12, 2, 2, 1951, 1952, 9, 8, 2, 2, 1952, 1953, 9, 6, 2, 2, 1953, 1954, 9, 10, 2, 2, 1954, 1955, 9, 5, 2, 2, 1955, 177, 3, 2, 2, 2, 1956, 1957, 9, 16, 2, 2, 1957, 1958, 9, 12, 2, 2, 1958, 1959, 9, 5, 2, 2, 1959, 1960, 9, 7, 2, 2, 1960, 1961, 9, 6, 2, 2, 1961, 179, 3, 2, 2, 2, 1962, 1963, 9, 16, 2, 2, 1963, 1964, 9, 4, 2, 2, 1964, 1965, 9, 8, 2, 2, 1965, 1966, 9, 8, 2, 2, 1966, 1967, 9, 4, 2, 2, 1967, 1968, 9, 18, 2, 2, 1968, 1969, 9, 12, 2, 2, 1969, 1970, 9, 13, 2, 2, 1970, 1971, 9, 17, 2, 2, 1971, 181, 3, 2, 2, 2, 1972, 1973, 9, 16, 2, 2, 1973, 1974, 9, 4, 2, 2, 1974, 1975, 9, 5, 2, 2, 1975, 1976, 9, 11, 2, 2, 1976, 1977, 9, 10, 2, 2, 1977, 183, 3, 2, 2, 2, 1978, 1979, 9, 16, 2, 2, 1979, 1980, 9, 4, 2, 2, 1980, 1981, 9, 5, 2, 2, 1981, 1982, 9, 18, 2, 2, 1982, 1983, 9, 2, 2, 2, 1983, 1984, 9, 5, 2, 2, 1984, 1985, 9, 14, 2, 2, 1985, 185, 3, 2, 2, 2, 1986, 1987, 9, 16, 2, 2, 1987, 1988, 9, 9, 2, 2, 1988, 1989, 9, 13, 2, 2, 1989, 1990, 9, 11, 2, 2, 1990, 1991, 9, 6, 2, 2, 1991, 1992, 9, 12, 2, 2, 1992, 1993, 9, 4, 2, 2, 1993, 1994, 9, 13, 2, 2, 1994, 187, 3, 2, 2, 2, 1995, 1996, 9, 16, 2, 2, 1996, 1997, 9, 9, 2, 2, 1997, 1998, 9, 13, 2, 2, 1998, 1999, 9, 11, 2, 2, 1999, 2000, 9, 6, 2, 2, 2000, 2001, 9, 12, 2, 2, 2001, 2002, 9, 4, 2, 2, 2002, 2003, 9, 13, 2, 2, 2003, 2004, 9, 7, 2, 2, 2004, 189, 3, 2, 2, 2, 2005, 2006, 9, 17, 2, 2, 2006, 2007, 9, 10, 2, 2, 2007, 2008, 9, 13, 2, 2, 2008, 2009, 9, 10, 2, 2, 2009, 2010, 9, 5, 2, 2, 2010, 2011, 9, 2, 2, 2, 2011, 2012, 9, 6, 2, 2, 2012, 2013, 9, 10, 2, 2, 2013, 2014, 9, 14, 2, 2, 2014, 191, 3, 2, 2, 2, 2015, 2016, 9, 17, 2, 2, 2016, 2017, 9, 8, 2, 2, 2017, 2018, 9, 4, 2, 2, 2018, 2019, 9, 3, 2, 2, 2019, 2020, 9, 2, 2, 2, 2020, 2021, 9, 8, 2, 2, 2021, 193, 3, 2, 2, 2, 2022, 2023, 9, 17, 2, 2, 2023, 2024, 9, 5, 2, 2, 2024, 2025, 9, 2, 2, 2, 2025, 2026, 9, 13, 2, 2, 2026, 2027, 9, 6, 2, 2, 2027, 2028, 9, 10, 2, 2, 2028, 2029, 9, 14, 2, 2, 2029, 195, 3, 2, 2, 2, 2030, 2031, 9, 17, 2, 2, 2031, 2032, 9, 5, 2, 2, 2032, 2033, 9, 4, 2, 2, 2033, 2034, 9, 9, 2, 2, 2034, 2035, 9, 22, 2, 2, 2035, 2036, 9, 7, 2, 2, 2036, 197, 3, 2, 2, 2, 2037, 2038, 9, 20, 2, 2, 2038, 2039, 9, 2, 2, 2, 2039, 2040, 9, 13, 2, 2, 2040, 2041, 9, 14, 2, 2, 2041, 2042, 9, 8, 2, 2, 2042, 2043, 9, 10, 2, 2, 2043, 2044, 9, 5, 2, 2, 2044, 199, 3, 2, 2, 2, 2045, 2046, 9, 20, 2, 2, 2046, 2047, 9, 10, 2, 2, 2047, 2048, 9, 2, 2, 2, 2048, 2049, 9, 14, 2, 2, 2049, 2050, 9, 10, 2, 2, 2050, 2051, 9, 5, 2, 2, 2051, 201, 3, 2, 2, 2, 2052, 2053, 9, 20, 2, 2, 2053, 2054, 9, 4, 2, 2, 2054, 2055, 9, 8, 2, 2, 2055, 2056, 9, 14, 2, 2, 2056, 203, 3, 2, 2, 2, 2057, 2058, 9, 20, 2, 2, 2058, 2059, 9, 4, 2, 2, 2059, 2060, 9, 9, 2, 2, 2060, 2061, 9, 5, 2, 2, 2061, 205, 3, 2, 2, 2, 2062, 2063, 9, 12, 2, 2, 2063, 2064, 9, 14, 2, 2, 2064, 2065, 9, 10, 2, 2, 2065, 2066, 9, 13, 2, 2, 2066, 2067, 9, 6, 2, 2, 2067, 2068, 9, 12, 2, 2, 2068, 2069, 9, 6, 2, 2, 2069, 2070, 9, 19, 2, 2, 2070, 207, 3, 2, 2, 2, 2071, 2072, 9, 12, 2, 2, 2072, 2073, 9, 16, 2, 2, 2073, 209, 3, 2, 2, 2, 2074, 2075, 9, 12, 2, 2, 2075, 2076, 9, 15, 2, 2, 2076, 2077, 9, 15, 2, 2, 2077, 2078, 9, 10, 2, 2, 2078, 2079, 9, 14, 2, 2, 2079, 2080, 9, 12, 2, 2, 2080, 2081, 9, 2, 2, 2, 2081, 2082, 9, 6, 2, 2, 2082, 2083, 9, 10, 2, 2, 2083, 211, 3, 2, 2, 2, 2084, 2085, 9, 12, 2, 2, 2085, 2086, 9, 15, 2, 2, 2086, 2087, 9, 15, 2, 2, 2087, 2088, 9, 9, 2, 2, 2088, 2089, 9, 6, 2, 2, 2089, 2090, 9, 2, 2, 2, 2090, 2091, 9, 3, 2, 2, 2091, 2092, 9, 8, 2, 2, 2092, 2093, 9, 10, 2, 2, 2093, 213, 3, 2, 2, 2, 2094, 2095, 9, 12, 2, 2, 2095, 2096, 9, 15, 2, 2, 2096, 2097, 9, 22, 2, 2, 2097, 2098, 9, 8, 2, 2, 2098, 2099, 9, 12, 2, 2, 2099, 2100, 9, 11, 2, 2, 2100, 2101, 9, 12, 2, 2, 2101, 2102, 9, 6, 2, 2, 2102, 215, 3, 2, 2, 2, 2103, 2104, 9, 12, 2, 2, 2104, 2105, 9, 15, 2, 2, 2105, 2106, 9, 22, 2, 2, 2106, 2107, 9, 4, 2, 2, 2107, 2108, 9, 5, 2, 2, 2108, 2109, 9, 6, 2, 2, 2109, 217, 3, 2, 2, 2, 2110, 2111, 9, 12, 2, 2, 2111, 2112, 9, 13, 2, 2, 2112, 2113, 9, 11, 2, 2, 2113, 2114, 9, 8, 2, 2, 2114, 2115, 9, 9, 2, 2, 2115, 2116, 9, 14, 2, 2, 2116, 2117, 9, 10, 2, 2, 2117, 219, 3, 2, 2, 2, 2118, 2119, 9, 12, 2, 2, 2119, 2120, 9, 13, 2, 2, 2120, 2121, 9, 11, 2, 2, 2121, 2122, 9, 8, 2, 2, 2122, 2123, 9, 9, 2, 2, 2123, 2124, 9, 14, 2, 2, 2124, 2125, 9, 12, 2, 2, 2125, 2126, 9, 13, 2, 2, 2126, 2127, 9, 17, 2, 2, 2127, 221, 3, 2, 2, 2, 2128, 2129, 9, 12, 2, 2, 2129, 2130, 9, 13, 2, 2, 2130, 2131, 9, 11, 2, 2, 2131, 2132, 9, 5, 2, 2, 2132, 2133, 9, 10, 2, 2, 2133, 2134, 9, 15, 2, 2, 2134, 2135, 9, 10, 2, 2, 2135, 2136, 9, 13, 2, 2, 2136, 2137, 9, 6, 2, 2, 2137, 223, 3, 2, 2, 2, 2138, 2139, 9, 12, 2, 2, 2139, 2140, 9, 13, 2, 2, 2140, 2141, 9, 14, 2, 2, 2141, 2142, 9, 10, 2, 2, 2142, 2143, 9, 24, 2, 2, 2143, 225, 3, 2, 2, 2, 2144, 2145, 9, 12, 2, 2, 2145, 2146, 9, 13, 2, 2, 2146, 2147, 9, 14, 2, 2, 2147, 2148, 9, 10, 2, 2, 2148, 2149, 9, 24, 2, 2, 2149, 2150, 9, 10, 2, 2, 2150, 2151, 9, 7, 2, 2, 2151, 227, 3, 2, 2, 2, 2152, 2153, 9, 12, 2, 2, 2153, 2154, 9, 13, 2, 2, 2154, 2155, 9, 20, 2, 2, 2155, 2156, 9, 10, 2, 2, 2156, 2157, 9, 5, 2, 2, 2157, 2158, 9, 12, 2, 2, 2158, 2159, 9, 6, 2, 2, 2159, 229, 3, 2, 2, 2, 2160, 2161, 9, 12, 2, 2, 2161, 2162, 9, 13, 2, 2, 2162, 2163, 9, 20, 2, 2, 2163, 2164, 9, 10, 2, 2, 2164, 2165, 9, 5, 2, 2, 2165, 2166, 9, 12, 2, 2, 2166, 2167, 9, 6, 2, 2, 2167, 2168, 9, 7, 2, 2, 2168, 231, 3, 2, 2, 2, 2169, 2170, 9, 12, 2, 2, 2170, 2171, 9, 13, 2, 2, 2171, 2172, 9, 8, 2, 2, 2172, 2173, 9, 12, 2, 2, 2173, 2174, 9, 13, 2, 2, 2174, 2175, 9, 10, 2, 2, 2175, 233, 3, 2, 2, 2, 2176, 2177, 9, 12, 2, 2, 2177, 2178, 9, 13, 2, 2, 2178, 2179, 9, 22, 2, 2, 2179, 2180, 9, 9, 2, 2, 2180, 2181, 9, 6, 2, 2, 2181, 235, 3, 2, 2, 2, 2182, 2183, 9, 12, 2, 2, 2183, 2184, 9, 13, 2, 2, 2184, 2185, 9, 7, 2, 2, 2185, 2186, 9, 10, 2, 2, 2186, 2187, 9, 13, 2, 2, 2187, 2188, 9, 7, 2, 2, 2188, 2189, 9, 12, 2, 2, 2189, 2190, 9, 6, 2, 2, 2190, 2191, 9, 12, 2, 2, 2191, 2192, 9, 23, 2, 2, 2192, 2193, 9, 10, 2, 2, 2193, 237, 3, 2, 2, 2, 2194, 2195, 9, 12, 2, 2, 2195, 2196, 9, 13, 2, 2, 2196, 2197, 9, 7, 2, 2, 2197, 2198, 9, 10, 2, 2, 2198, 2199, 9, 5, 2, 2, 2199, 2200, 9, 6, 2, 2, 2200, 239, 3, 2, 2, 2, 2201, 2202, 9, 12, 2, 2, 2202, 2203, 9, 13, 2, 2, 2203, 2204, 9, 7, 2, 2, 2204, 2205, 9, 6, 2, 2, 2205, 2206, 9, 10, 2, 2, 2206, 2207, 9, 2, 2, 2, 2207, 2208, 9, 14, 2, 2, 2208, 241, 3, 2, 2, 2, 2209, 2210, 9, 12, 2, 2, 2210, 2211, 9, 13, 2, 2, 2211, 2212, 9, 23, 2, 2, 2212, 2213, 9, 4, 2, 2, 2213, 2214, 9, 21, 2, 2, 2214, 2215, 9, 10, 2, 2, 2215, 2216, 9, 5, 2, 2, 2216, 243, 3, 2, 2, 2, 2217, 2218, 9, 12, 2, 2, 2218, 2219, 9, 7, 2, 2, 2219, 2220, 9, 4, 2, 2, 2220, 2221, 9, 8, 2, 2, 2221, 2222, 9, 2, 2, 2, 2222, 2223, 9, 6, 2, 2, 2223, 2224, 9, 12, 2, 2, 2224, 2225, 9, 4, 2, 2, 2225, 2226, 9, 13, 2, 2, 2226, 245, 3, 2, 2, 2, 2227, 2228, 9, 21, 2, 2, 2228, 2229, 9, 10, 2, 2, 2229, 2230, 9, 19, 2, 2, 2230, 247, 3, 2, 2, 2, 2231, 2232, 9, 8, 2, 2, 2232, 2233, 9, 2, 2, 2, 2233, 2234, 9, 3, 2, 2, 2234, 2235, 9, 10, 2, 2, 2235, 2236, 9, 8, 2, 2, 2236, 249, 3, 2, 2, 2, 2237, 2238, 9, 8, 2, 2, 2238, 2239, 9, 2, 2, 2, 2239, 2240, 9, 13, 2, 2, 2240, 2241, 9, 17, 2, 2, 2241, 2242, 9, 9, 2, 2, 2242, 2243, 9, 2, 2, 2, 2243, 2244, 9, 17, 2, 2, 2244, 2245, 9, 10, 2, 2, 2245, 251, 3, 2, 2, 2, 2246, 2247, 9, 8, 2, 2, 2247, 2248, 9, 2, 2, 2, 2248, 2249, 9, 5, 2, 2, 2249, 2250, 9, 17, 2, 2, 2250, 2251, 9, 10, 2, 2, 2251, 253, 3, 2, 2, 2, 2252, 2253, 9, 8, 2, 2, 2253, 2254, 9, 2, 2, 2, 2254, 2255, 9, 7, 2, 2, 2255, 2256, 9, 6, 2, 2, 2256, 255, 3, 2, 2, 2, 2257, 2258, 9, 8, 2, 2, 2258, 2259, 9, 10, 2, 2, 2259, 2260, 9, 2, 2, 2, 2260, 2261, 9, 21, 2, 2, 2261, 2262, 9, 22, 2, 2, 2262, 2263, 9, 5, 2, 2, 2263, 2264, 9, 4, 2, 2, 2264, 2265, 9, 4, 2, 2, 2265, 2266, 9, 16, 2, 2, 2266, 257, 3, 2, 2, 2, 2267, 2268, 9, 8, 2, 2, 2268, 2269, 9, 10, 2, 2, 2269, 2270, 9, 23, 2, 2, 2270, 2271, 9, 10, 2, 2, 2271, 2272, 9, 8, 2, 2, 2272, 259, 3, 2, 2, 2, 2273, 2274, 9, 8, 2, 2, 2274, 2275, 9, 12, 2, 2, 2275, 2276, 9, 7, 2, 2, 2276, 2277, 9, 6, 2, 2, 2277, 2278, 9, 10, 2, 2, 2278, 2279, 9, 13, 2, 2, 2279, 261, 3, 2, 2, 2, 2280, 2281, 9, 8, 2, 2, 2281, 2282, 9, 4, 2, 2, 2282, 2283, 9, 2, 2, 2, 2283, 2284, 9, 14, 2, 2, 2284, 263, 3, 2, 2, 2, 2285, 2286, 9, 8, 2, 2, 2286, 2287, 9, 4, 2, 2, 2287, 2288, 9, 11, 2, 2, 2288, 2289, 9, 2, 2, 2, 2289, 2290, 9, 8, 2, 2, 2290, 265, 3, 2, 2, 2, 2291, 2292, 9, 8, 2, 2, 2292, 2293, 9, 4, 2, 2, 2293, 2294, 9, 11, 2, 2, 2294, 2295, 9, 2, 2, 2, 2295, 2296, 9, 6, 2, 2, 2296, 2297, 9, 12, 2, 2, 2297, 2298, 9, 4, 2, 2, 2298, 2299, 9, 13, 2, 2, 2299, 267, 3, 2, 2, 2, 2300, 2301, 9, 8, 2, 2, 2301, 2302, 9, 4, 2, 2, 2302, 2303, 9, 11, 2, 2, 2303, 2304, 9, 21, 2, 2, 2304, 269, 3, 2, 2, 2, 2305, 2306, 9, 8, 2, 2, 2306, 2307, 9, 4, 2, 2, 2307, 2308, 9, 11, 2, 2, 2308, 2309, 9, 21, 2, 2, 2309, 2310, 9, 10, 2, 2, 2310, 2311, 9, 14, 2, 2, 2311, 271, 3, 2, 2, 2, 2312, 2313, 9, 8, 2, 2, 2313, 2314, 9, 4, 2, 2, 2314, 2315, 9, 17, 2, 2, 2315, 2316, 9, 17, 2, 2, 2316, 2317, 9, 10, 2, 2, 2317, 2318, 9, 14, 2, 2, 2318, 273, 3, 2, 2, 2, 2319, 2320, 9, 15, 2, 2, 2320, 2321, 9, 2, 2, 2, 2321, 2322, 9, 22, 2, 2, 2322, 2323, 9, 22, 2, 2, 2323, 2324, 9, 12, 2, 2, 2324, 2325, 9, 13, 2, 2, 2325, 2326, 9, 17, 2, 2, 2326, 275, 3, 2, 2, 2, 2327, 2328, 9, 15, 2, 2, 2328, 2329, 9, 2, 2, 2, 2329, 2330, 9, 6, 2, 2, 2330, 2331, 9, 11, 2, 2, 2331, 2332, 9, 20, 2, 2, 2332, 277, 3, 2, 2, 2, 2333, 2334, 9, 15, 2, 2, 2334, 2335, 9, 2, 2, 2, 2335, 2336, 9, 6, 2, 2, 2336, 2337, 9, 10, 2, 2, 2337, 2338, 9, 5, 2, 2, 2338, 2339, 9, 12, 2, 2, 2339, 2340, 9, 2, 2, 2, 2340, 2341, 9, 8, 2, 2, 2341, 2342, 9, 12, 2, 2, 2342, 2343, 9, 25, 2, 2, 2343, 2344, 9, 10, 2, 2, 2344, 2345, 9, 14, 2, 2, 2345, 279, 3, 2, 2, 2, 2346, 2347, 9, 15, 2, 2, 2347, 2348, 9, 2, 2, 2, 2348, 2349, 9, 24, 2, 2, 2349, 2350, 9, 23, 2, 2, 2350, 2351, 9, 2, 2, 2, 2351, 2352, 9, 8, 2, 2, 2352, 2353, 9, 9, 2, 2, 2353, 2354, 9, 10, 2, 2, 2354, 281, 3, 2, 2, 2, 2355, 2356, 9, 15, 2, 2, 2356, 2357, 9, 10, 2, 2, 2357, 2358, 9, 6, 2, 2, 2358, 2359, 9, 20, 2, 2, 2359, 2360, 9, 4, 2, 2, 2360, 2361, 9, 14, 2, 2, 2361, 283, 3, 2, 2, 2, 2362, 2363, 9, 15, 2, 2, 2363, 2364, 9, 12, 2, 2, 2364, 2365, 9, 13, 2, 2, 2365, 2366, 9, 9, 2, 2, 2366, 2367, 9, 6, 2, 2, 2367, 2368, 9, 10, 2, 2, 2368, 285, 3, 2, 2, 2, 2369, 2370, 9, 15, 2, 2, 2370, 2371, 9, 12, 2, 2, 2371, 2372, 9, 13, 2, 2, 2372, 2373, 9, 23, 2, 2, 2373, 2374, 9, 2, 2, 2, 2374, 2375, 9, 8, 2, 2, 2375, 2376, 9, 9, 2, 2, 2376, 2377, 9, 10, 2, 2, 2377, 287, 3, 2, 2, 2, 2378, 2379, 9, 15, 2, 2, 2379, 2380, 9, 4, 2, 2, 2380, 2381, 9, 14, 2, 2, 2381, 2382, 9, 10, 2, 2, 2382, 289, 3, 2, 2, 2, 2383, 2384, 9, 15, 2, 2, 2384, 2385, 9, 4, 2, 2, 2385, 2386, 9, 13, 2, 2, 2386, 2387, 9, 6, 2, 2, 2387, 2388, 9, 20, 2, 2, 2388, 291, 3, 2, 2, 2, 2389, 2390, 9, 15, 2, 2, 2390, 2391, 9, 4, 2, 2, 2391, 2392, 9, 23, 2, 2, 2392, 2393, 9, 10, 2, 2, 2393, 293, 3, 2, 2, 2, 2394, 2395, 9, 13, 2, 2, 2395, 2396, 9, 2, 2, 2, 2396, 2397, 9, 15, 2, 2, 2397, 2398, 9, 10, 2, 2, 2398, 295, 3, 2, 2, 2, 2399, 2400, 9, 13, 2, 2, 2400, 2401, 9, 2, 2, 2, 2401, 2402, 9, 15, 2, 2, 2402, 2403, 9, 10, 2, 2, 2403, 2404, 9, 7, 2, 2, 2404, 297, 3, 2, 2, 2, 2405, 2406, 9, 13, 2, 2, 2406, 2407, 9, 10, 2, 2, 2407, 2408, 9, 18, 2, 2, 2408, 299, 3, 2, 2, 2, 2409, 2410, 9, 13, 2, 2, 2410, 2411, 9, 10, 2, 2, 2411, 2412, 9, 24, 2, 2, 2412, 2413, 9, 6, 2, 2, 2413, 301, 3, 2, 2, 2, 2414, 2415, 9, 13, 2, 2, 2415, 2416, 9, 4, 2, 2, 2416, 303, 3, 2, 2, 2, 2417, 2418, 9, 13, 2, 2, 2418, 2419, 9, 4, 2, 2, 2419, 2420, 9, 6, 2, 2, 2420, 2421, 9, 20, 2, 2, 2421, 2422, 9, 12, 2, 2, 2422, 2423, 9, 13, 2, 2, 2423, 2424, 9, 17, 2, 2, 2424, 305, 3, 2, 2, 2, 2425, 2426, 9, 13, 2, 2, 2426, 2427, 9, 4, 2, 2, 2427, 2428, 9, 6, 2, 2, 2428, 2429, 9, 12, 2, 2, 2429, 2430, 9, 16, 2, 2, 2430, 2431, 9, 19, 2, 2, 2431, 307, 3, 2, 2, 2, 2432, 2433, 9, 13, 2, 2, 2433, 2434, 9, 4, 2, 2, 2434, 2435, 9, 18, 2, 2, 2435, 2436, 9, 2, 2, 2, 2436, 2437, 9, 12, 2, 2, 2437, 2438, 9, 6, 2, 2, 2438, 309, 3, 2, 2, 2, 2439, 2440, 9, 13, 2, 2, 2440, 2441, 9, 9, 2, 2, 2441, 2442, 9, 8, 2, 2, 2442, 2443, 9, 8, 2, 2, 2443, 2444, 9, 7, 2, 2, 2444, 311, 3, 2, 2, 2, 2445, 2446, 9, 4, 2, 2, 2446, 2447, 9, 3, 2, 2, 2447, 2448, 9, 26, 2, 2, 2448, 2449, 9, 10, 2, 2, 2449, 2450, 9, 11, 2, 2, 2450, 2451, 9, 6, 2, 2, 2451, 313, 3, 2, 2, 2, 2452, 2453, 9, 4, 2, 2, 2453, 2454, 9, 16, 2, 2, 2454, 315, 3, 2, 2, 2, 2455, 2456, 9, 4, 2, 2, 2456, 2457, 9, 16, 2, 2, 2457, 2458, 9, 16, 2, 2, 2458, 317, 3, 2, 2, 2, 2459, 2460, 9, 4, 2, 2, 2460, 2461, 9, 12, 2, 2, 2461, 2462, 9, 14, 2, 2, 2462, 2463, 9, 7, 2, 2, 2463, 319, 3, 2, 2, 2, 2464, 2465, 9, 4, 2, 2, 2465, 2466, 9, 8, 2, 2, 2466, 2467, 9, 14, 2, 2, 2467, 321, 3, 2, 2, 2, 2468, 2469, 9, 4, 2, 2, 2469, 2470, 9, 22, 2, 2, 2470, 2471, 9, 10, 2, 2, 2471, 2472, 9, 5, 2, 2, 2472, 2473, 9, 2, 2, 2, 2473, 2474, 9, 6, 2, 2, 2474, 2475, 9, 4, 2, 2, 2475, 2476, 9, 5, 2, 2, 2476, 323, 3, 2, 2, 2, 2477, 2478, 9, 4, 2, 2, 2478, 2479, 9, 22, 2, 2, 2479, 2480, 9, 6, 2, 2, 2480, 2481, 9, 12, 2, 2, 2481, 2482, 9, 4, 2, 2, 2482, 2483, 9, 13, 2, 2, 2483, 325, 3, 2, 2, 2, 2484, 2485, 9, 4, 2, 2, 2485, 2486, 9, 22, 2, 2, 2486, 2487, 9, 6, 2, 2, 2487, 2488, 9, 12, 2, 2, 2488, 2489, 9, 4, 2, 2, 2489, 2490, 9, 13, 2, 2, 2490, 2491, 9, 7, 2, 2, 2491, 327, 3, 2, 2, 2, 2492, 2493, 9, 4, 2, 2, 2493, 2494, 9, 5, 2, 2, 2494, 2495, 9, 14, 2, 2, 2495, 2496, 9, 12, 2, 2, 2496, 2497, 9, 13, 2, 2, 2497, 2498, 9, 2, 2, 2, 2498, 2499, 9, 8, 2, 2, 2499, 2500, 9, 12, 2, 2, 2500, 2501, 9, 6, 2, 2, 2501, 2502, 9, 19, 2, 2, 2502, 329, 3, 2, 2, 2, 2503, 2504, 9, 4, 2, 2, 2504, 2505, 9, 6, 2, 2, 2505, 2506, 9, 20, 2, 2, 2506, 2507, 9, 10, 2, 2, 2507, 2508, 9, 5, 2, 2, 2508, 2509, 9, 7, 2, 2, 2509, 331, 3, 2, 2, 2, 2510, 2511, 9, 4, 2, 2, 2511, 2512, 9, 23, 2, 2, 2512, 2513, 9, 10, 2, 2, 2513, 2514, 9, 5, 2, 2, 2514, 333, 3, 2, 2, 2, 2515, 2516, 9, 4, 2, 2, 2516, 2517, 9, 23, 2, 2, 2517, 2518, 9, 10, 2, 2, 2518, 2519, 9, 5, 2, 2, 2519, 2520, 9, 5, 2, 2, 2520, 2521, 9, 12, 2, 2, 2521, 2522, 9, 14, 2, 2, 2522, 2523, 9, 12, 2, 2, 2523, 2524, 9, 13, 2, 2, 2524, 2525, 9, 17, 2, 2, 2525, 335, 3, 2, 2, 2, 2526, 2527, 9, 4, 2, 2, 2527, 2528, 9, 18, 2, 2, 2528, 2529, 9, 13, 2, 2, 2529, 2530, 9, 10, 2, 2, 2530, 2531, 9, 14, 2, 2, 2531, 337, 3, 2, 2, 2, 2532, 2533, 9, 4, 2, 2, 2533, 2534, 9, 18, 2, 2, 2534, 2535, 9, 13, 2, 2, 2535, 2536, 9, 10, 2, 2, 2536, 2537, 9, 5, 2, 2, 2537, 339, 3, 2, 2, 2, 2538, 2539, 9, 22, 2, 2, 2539, 2540, 9, 2, 2, 2, 2540, 2541, 9, 5, 2, 2, 2541, 2542, 9, 2, 2, 2, 2542, 2543, 9, 8, 2, 2, 2543, 2544, 9, 8, 2, 2, 2544, 2545, 9, 10, 2, 2, 2545, 2546, 9, 8, 2, 2, 2546, 341, 3, 2, 2, 2, 2547, 2548, 9, 22, 2, 2, 2548, 2549, 9, 2, 2, 2, 2549, 2550, 9, 5, 2, 2, 2550, 2551, 9, 7, 2, 2, 2551, 2552, 9, 10, 2, 2, 2552, 2553, 9, 5, 2, 2, 2553, 343, 3, 2, 2, 2, 2554, 2555, 9, 22, 2, 2, 2555, 2556, 9, 2, 2, 2, 2556, 2557, 9, 5, 2, 2, 2557, 2558, 9, 6, 2, 2, 2558, 2559, 9, 12, 2, 2, 2559, 2560, 9, 2, 2, 2, 2560, 2561, 9, 8, 2, 2, 2561, 345, 3, 2, 2, 2, 2562, 2563, 9, 22, 2, 2, 2563, 2564, 9, 2, 2, 2, 2564, 2565, 9, 5, 2, 2, 2565, 2566, 9, 6, 2, 2, 2566, 2567, 9, 12, 2, 2, 2567, 2568, 9, 6, 2, 2, 2568, 2569, 9, 12, 2, 2, 2569, 2570, 9, 4, 2, 2, 2570, 2571, 9, 13, 2, 2, 2571, 347, 3, 2, 2, 2, 2572, 2573, 9, 22, 2, 2, 2573, 2574, 9, 2, 2, 2, 2574, 2575, 9, 7, 2, 2, 2575, 2576, 9, 7, 2, 2, 2576, 2577, 9, 12, 2, 2, 2577, 2578, 9, 13, 2, 2, 2578, 2579, 9, 17, 2, 2, 2579, 349, 3, 2, 2, 2, 2580, 2581, 9, 22, 2, 2, 2581, 2582, 9, 2, 2, 2, 2582, 2583, 9, 7, 2, 2, 2583, 2584, 9, 7, 2, 2, 2584, 2585, 9, 18, 2, 2, 2585, 2586, 9, 4, 2, 2, 2586, 2587, 9, 5, 2, 2, 2587, 2588, 9, 14, 2, 2, 2588, 351, 3, 2, 2, 2, 2589, 2590, 9, 22, 2, 2, 2590, 2591, 9, 8, 2, 2, 2591, 2592, 9, 2, 2, 2, 2592, 2593, 9, 13, 2, 2, 2593, 2594, 9, 7, 2, 2, 2594, 353, 3, 2, 2, 2, 2595, 2596, 9, 22, 2, 2, 2596, 2597, 9, 4, 2, 2, 2597, 2598, 9, 8, 2, 2, 2598, 2599, 9, 12, 2, 2, 2599, 2600, 9, 11, 2, 2, 2600, 2601, 9, 19, 2, 2, 2601, 355, 3, 2, 2, 2, 2602, 2603, 9, 22, 2, 2, 2603, 2604, 9, 5, 2, 2, 2604, 2605, 9, 10, 2, 2, 2605, 2606, 9, 11, 2, 2, 2606, 2607, 9, 10, 2, 2, 2607, 2608, 9, 14, 2, 2, 2608, 2609, 9, 12, 2, 2, 2609, 2610, 9, 13, 2, 2, 2610, 2611, 9, 17, 2, 2, 2611, 357, 3, 2, 2, 2, 2612, 2613, 9, 22, 2, 2, 2613, 2614, 9, 5, 2, 2, 2614, 2615, 9, 10, 2, 2, 2615, 2616, 9, 22, 2, 2, 2616, 2617, 9, 2, 2, 2, 2617, 2618, 9, 5, 2, 2, 2618, 2619, 9, 10, 2, 2, 2619, 359, 3, 2, 2, 2, 2620, 2621, 9, 22, 2, 2, 2621, 2622, 9, 5, 2, 2, 2622, 2623, 9, 10, 2, 2, 2623, 2624, 9, 22, 2, 2, 2624, 2625, 9, 2, 2, 2, 2625, 2626, 9, 5, 2, 2, 2626, 2627, 9, 10, 2, 2, 2627, 2628, 9, 14, 2, 2, 2628, 361, 3, 2, 2, 2, 2629, 2630, 9, 22, 2, 2, 2630, 2631, 9, 5, 2, 2, 2631, 2632, 9, 10, 2, 2, 2632, 2633, 9, 7, 2, 2, 2633, 2634, 9, 10, 2, 2, 2634, 2635, 9, 5, 2, 2, 2635, 2636, 9, 23, 2, 2, 2636, 2637, 9, 10, 2, 2, 2637, 363, 3, 2, 2, 2, 2638, 2639, 9, 22, 2, 2, 2639, 2640, 9, 5, 2, 2, 2640, 2641, 9, 12, 2, 2, 2641, 2642, 9, 4, 2, 2, 2642, 2643, 9, 5, 2, 2, 2643, 365, 3, 2, 2, 2, 2644, 2645, 9, 22, 2, 2, 2645, 2646, 9, 5, 2, 2, 2646, 2647, 9, 12, 2, 2, 2647, 2648, 9, 23, 2, 2, 2648, 2649, 9, 12, 2, 2, 2649, 2650, 9, 8, 2, 2, 2650, 2651, 9, 10, 2, 2, 2651, 2652, 9, 17, 2, 2, 2652, 2653, 9, 10, 2, 2, 2653, 2654, 9, 7, 2, 2, 2654, 367, 3, 2, 2, 2, 2655, 2656, 9, 22, 2, 2, 2656, 2657, 9, 5, 2, 2, 2657, 2658, 9, 4, 2, 2, 2658, 2659, 9, 11, 2, 2, 2659, 2660, 9, 10, 2, 2, 2660, 2661, 9, 14, 2, 2, 2661, 2662, 9, 9, 2, 2, 2662, 2663, 9, 5, 2, 2, 2663, 2664, 9, 2, 2, 2, 2664, 2665, 9, 8, 2, 2, 2665, 369, 3, 2, 2, 2, 2666, 2667, 9, 22, 2, 2, 2667, 2668, 9, 5, 2, 2, 2668, 2669, 9, 4, 2, 2, 2669, 2670, 9, 11, 2, 2, 2670, 2671, 9, 10, 2, 2, 2671, 2672, 9, 14, 2, 2, 2672, 2673, 9, 9, 2, 2, 2673, 2674, 9, 5, 2, 2, 2674, 2675, 9, 10, 2, 2, 2675, 371, 3, 2, 2, 2, 2676, 2677, 9, 22, 2, 2, 2677, 2678, 9, 5, 2, 2, 2678, 2679, 9, 4, 2, 2, 2679, 2680, 9, 11, 2, 2, 2680, 2681, 9, 10, 2, 2, 2681, 2682, 9, 14, 2, 2, 2682, 2683, 9, 9, 2, 2, 2683, 2684, 9, 5, 2, 2, 2684, 2685, 9, 10, 2, 2, 2685, 2686, 9, 7, 2, 2, 2686, 373, 3, 2, 2, 2, 2687, 2688, 9, 22, 2, 2, 2688, 2689, 9, 5, 2, 2, 2689, 2690, 9, 4, 2, 2, 2690, 2691, 9, 17, 2, 2, 2691, 2692, 9, 5, 2, 2, 2692, 2693, 9, 2, 2, 2, 2693, 2694, 9, 15, 2, 2, 2694, 375, 3, 2, 2, 2, 2695, 2696, 9, 22, 2, 2, 2696, 2697, 9, 9, 2, 2, 2697, 2698, 9, 3, 2, 2, 2698, 2699, 9, 8, 2, 2, 2699, 2700, 9, 12, 2, 2, 2700, 2701, 9, 11, 2, 2, 2701, 2702, 9, 2, 2, 2, 2702, 2703, 9, 6, 2, 2, 2703, 2704, 9, 12, 2, 2, 2704, 2705, 9, 4, 2, 2, 2705, 2706, 9, 13, 2, 2, 2706, 377, 3, 2, 2, 2, 2707, 2708, 9, 27, 2, 2, 2708, 2709, 9, 9, 2, 2, 2709, 2710, 9, 4, 2, 2, 2710, 2711, 9, 6, 2, 2, 2711, 2712, 9, 10, 2, 2, 2712, 379, 3, 2, 2, 2, 2713, 2714, 9, 5, 2, 2, 2714, 2715, 9, 2, 2, 2, 2715, 2716, 9, 13, 2, 2, 2716, 2717, 9, 17, 2, 2, 2717, 2718, 9, 10, 2, 2, 2718, 381, 3, 2, 2, 2, 2719, 2720, 9, 5, 2, 2, 2720, 2721, 9, 10, 2, 2, 2721, 2722, 9, 2, 2, 2, 2722, 2723, 9, 14, 2, 2, 2723, 383, 3, 2, 2, 2, 2724, 2725, 9, 5, 2, 2, 2725, 2726, 9, 10, 2, 2, 2726, 2727, 9, 2, 2, 2, 2727, 2728, 9, 7, 2, 2, 2728, 2729, 9, 7, 2, 2, 2729, 2730, 9, 12, 2, 2, 2730, 2731, 9, 17, 2, 2, 2731, 2732, 9, 13, 2, 2, 2732, 385, 3, 2, 2, 2, 2733, 2734, 9, 5, 2, 2, 2734, 2735, 9, 10, 2, 2, 2735, 2736, 9, 11, 2, 2, 2736, 2737, 9, 20, 2, 2, 2737, 2738, 9, 10, 2, 2, 2738, 2739, 9, 11, 2, 2, 2739, 2740, 9, 21, 2, 2, 2740, 387, 3, 2, 2, 2, 2741, 2742, 9, 5, 2, 2, 2742, 2743, 9, 10, 2, 2, 2743, 2744, 9, 11, 2, 2, 2744, 2745, 9, 9, 2, 2, 2745, 2746, 9, 5, 2, 2, 2746, 2747, 9, 7, 2, 2, 2747, 2748, 9, 12, 2, 2, 2748, 2749, 9, 23, 2, 2, 2749, 2750, 9, 10, 2, 2, 2750, 389, 3, 2, 2, 2, 2751, 2752, 9, 5, 2, 2, 2752, 2753, 9, 10, 2, 2, 2753, 2754, 9, 16, 2, 2, 2754, 391, 3, 2, 2, 2, 2755, 2756, 9, 5, 2, 2, 2756, 2757, 9, 10, 2, 2, 2757, 2758, 9, 16, 2, 2, 2758, 2759, 9, 10, 2, 2, 2759, 2760, 9, 5, 2, 2, 2760, 2761, 9, 10, 2, 2, 2761, 2762, 9, 13, 2, 2, 2762, 2763, 9, 11, 2, 2, 2763, 2764, 9, 12, 2, 2, 2764, 2765, 9, 13, 2, 2, 2765, 2766, 9, 17, 2, 2, 2766, 393, 3, 2, 2, 2, 2767, 2768, 9, 5, 2, 2, 2768, 2769, 9, 10, 2, 2, 2769, 2770, 9, 16, 2, 2, 2770, 2771, 9, 5, 2, 2, 2771, 2772, 9, 10, 2, 2, 2772, 2773, 9, 7, 2, 2, 2773, 2774, 9, 20, 2, 2, 2774, 395, 3, 2, 2, 2, 2775, 2776, 9, 5, 2, 2, 2776, 2777, 9, 10, 2, 2, 2777, 2778, 9, 12, 2, 2, 2778, 2779, 9, 13, 2, 2, 2779, 2780, 9, 14, 2, 2, 2780, 2781, 9, 10, 2, 2, 2781, 2782, 9, 24, 2, 2, 2782, 397, 3, 2, 2, 2, 2783, 2784, 9, 5, 2, 2, 2784, 2785, 9, 10, 2, 2, 2785, 2786, 9, 8, 2, 2, 2786, 2787, 9, 2, 2, 2, 2787, 2788, 9, 6, 2, 2, 2788, 2789, 9, 12, 2, 2, 2789, 2790, 9, 23, 2, 2, 2790, 2791, 9, 10, 2, 2, 2791, 399, 3, 2, 2, 2, 2792, 2793, 9, 5, 2, 2, 2793, 2794, 9, 10, 2, 2, 2794, 2795, 9, 8, 2, 2, 2795, 2796, 9, 10, 2, 2, 2796, 2797, 9, 2, 2, 2, 2797, 2798, 9, 7, 2, 2, 2798, 2799, 9, 10, 2, 2, 2799, 401, 3, 2, 2, 2, 2800, 2801, 9, 5, 2, 2, 2801, 2802, 9, 10, 2, 2, 2802, 2803, 9, 13, 2, 2, 2803, 2804, 9, 2, 2, 2, 2804, 2805, 9, 15, 2, 2, 2805, 2806, 9, 10, 2, 2, 2806, 403, 3, 2, 2, 2, 2807, 2808, 9, 5, 2, 2, 2808, 2809, 9, 10, 2, 2, 2809, 2810, 9, 22, 2, 2, 2810, 2811, 9, 10, 2, 2, 2811, 2812, 9, 2, 2, 2, 2812, 2813, 9, 6, 2, 2, 2813, 2814, 9, 2, 2, 2, 2814, 2815, 9, 3, 2, 2, 2815, 2816, 9, 8, 2, 2, 2816, 2817, 9, 10, 2, 2, 2817, 405, 3, 2, 2, 2, 2818, 2819, 9, 5, 2, 2, 2819, 2820, 9, 10, 2, 2, 2820, 2821, 9, 22, 2, 2, 2821, 2822, 9, 8, 2, 2, 2822, 2823, 9, 2, 2, 2, 2823, 2824, 9, 11, 2, 2, 2824, 2825, 9, 10, 2, 2, 2825, 407, 3, 2, 2, 2, 2826, 2827, 9, 5, 2, 2, 2827, 2828, 9, 10, 2, 2, 2828, 2829, 9, 22, 2, 2, 2829, 2830, 9, 8, 2, 2, 2830, 2831, 9, 12, 2, 2, 2831, 2832, 9, 11, 2, 2, 2832, 2833, 9, 2, 2, 2, 2833, 409, 3, 2, 2, 2, 2834, 2835, 9, 5, 2, 2, 2835, 2836, 9, 10, 2, 2, 2836, 2837, 9, 7, 2, 2, 2837, 2838, 9, 10, 2, 2, 2838, 2839, 9, 6, 2, 2, 2839, 411, 3, 2, 2, 2, 2840, 2841, 9, 5, 2, 2, 2841, 2842, 9, 10, 2, 2, 2842, 2843, 9, 7, 2, 2, 2843, 2844, 9, 6, 2, 2, 2844, 2845, 9, 2, 2, 2, 2845, 2846, 9, 5, 2, 2, 2846, 2847, 9, 6, 2, 2, 2847, 413, 3, 2, 2, 2, 2848, 2849, 9, 5, 2, 2, 2849, 2850, 9, 10, 2, 2, 2850, 2851, 9, 7, 2, 2, 2851, 2852, 9, 6, 2, 2, 2852, 2853, 9, 5, 2, 2, 2853, 2854, 9, 12, 2, 2, 2854, 2855, 9, 11, 2, 2, 2855, 2856, 9, 6, 2, 2, 2856, 415, 3, 2, 2, 2, 2857, 2858, 9, 5, 2, 2, 2858, 2859, 9, 10, 2, 2, 2859, 2860, 9, 6, 2, 2, 2860, 2861, 9, 9, 2, 2, 2861, 2862, 9, 5, 2, 2, 2862, 2863, 9, 13, 2, 2, 2863, 2864, 9, 7, 2, 2, 2864, 417, 3, 2, 2, 2, 2865, 2866, 9, 5, 2, 2, 2866, 2867, 9, 10, 2, 2, 2867, 2868, 9, 23, 2, 2, 2868, 2869, 9, 4, 2, 2, 2869, 2870, 9, 21, 2, 2, 2870, 2871, 9, 10, 2, 2, 2871, 419, 3, 2, 2, 2, 2872, 2873, 9, 5, 2, 2, 2873, 2874, 9, 4, 2, 2, 2874, 2875, 9, 8, 2, 2, 2875, 2876, 9, 10, 2, 2, 2876, 421, 3, 2, 2, 2, 2877, 2878, 9, 5, 2, 2, 2878, 2879, 9, 4, 2, 2, 2879, 2880, 9, 8, 2, 2, 2880, 2881, 9, 8, 2, 2, 2881, 2882, 9, 3, 2, 2, 2882, 2883, 9, 2, 2, 2, 2883, 2884, 9, 11, 2, 2, 2884, 2885, 9, 21, 2, 2, 2885, 423, 3, 2, 2, 2, 2886, 2887, 9, 5, 2, 2, 2887, 2888, 9, 4, 2, 2, 2888, 2889, 9, 8, 2, 2, 2889, 2890, 9, 8, 2, 2, 2890, 2891, 9, 9, 2, 2, 2891, 2892, 9, 22, 2, 2, 2892, 425, 3, 2, 2, 2, 2893, 2894, 9, 5, 2, 2, 2894, 2895, 9, 4, 2, 2, 2895, 2896, 9, 9, 2, 2, 2896, 2897, 9, 6, 2, 2, 2897, 2898, 9, 12, 2, 2, 2898, 2899, 9, 13, 2, 2, 2899, 2900, 9, 10, 2, 2, 2900, 427, 3, 2, 2, 2, 2901, 2902, 9, 5, 2, 2, 2902, 2903, 9, 4, 2, 2, 2903, 2904, 9, 9, 2, 2, 2904, 2905, 9, 6, 2, 2, 2905, 2906, 9, 12, 2, 2, 2906, 2907, 9, 13, 2, 2, 2907, 2908, 9, 10, 2, 2, 2908, 2909, 9, 7, 2, 2, 2909, 429, 3, 2, 2, 2, 2910, 2911, 9, 5, 2, 2, 2911, 2912, 9, 4, 2, 2, 2912, 2913, 9, 18, 2, 2, 2913, 2914, 9, 7, 2, 2, 2914, 431, 3, 2, 2, 2, 2915, 2916, 9, 5, 2, 2, 2916, 2917, 9, 9, 2, 2, 2917, 2918, 9, 8, 2, 2, 2918, 2919, 9, 10, 2, 2, 2919, 433, 3, 2, 2, 2, 2920, 2921, 9, 7, 2, 2, 2921, 2922, 9, 2, 2, 2, 2922, 2923, 9, 23, 2, 2, 2923, 2924, 9, 10, 2, 2, 2924, 2925, 9, 22, 2, 2, 2925, 2926, 9, 4, 2, 2, 2926, 2927, 9, 12, 2, 2, 2927, 2928, 9, 13, 2, 2, 2928, 2929, 9, 6, 2, 2, 2929, 435, 3, 2, 2, 2, 2930, 2931, 9, 7, 2, 2, 2931, 2932, 9, 11, 2, 2, 2932, 2933, 9, 20, 2, 2, 2933, 2934, 9, 10, 2, 2, 2934, 2935, 9, 15, 2, 2, 2935, 2936, 9, 2, 2, 2, 2936, 437, 3, 2, 2, 2, 2937, 2938, 9, 7, 2, 2, 2938, 2939, 9, 11, 2, 2, 2939, 2940, 9, 20, 2, 2, 2940, 2941, 9, 10, 2, 2, 2941, 2942, 9, 15, 2, 2, 2942, 2943, 9, 2, 2, 2, 2943, 2944, 9, 7, 2, 2, 2944, 439, 3, 2, 2, 2, 2945, 2946, 9, 7, 2, 2, 2946, 2947, 9, 11, 2, 2, 2947, 2948, 9, 5, 2, 2, 2948, 2949, 9, 4, 2, 2, 2949, 2950, 9, 8, 2, 2, 2950, 2951, 9, 8, 2, 2, 2951, 441, 3, 2, 2, 2, 2952, 2953, 9, 7, 2, 2, 2953, 2954, 9, 10, 2, 2, 2954, 2955, 9, 2, 2, 2, 2955, 2956, 9, 5, 2, 2, 2956, 2957, 9, 11, 2, 2, 2957, 2958, 9, 20, 2, 2, 2958, 443, 3, 2, 2, 2, 2959, 2960, 9, 7, 2, 2, 2960, 2961, 9, 10, 2, 2, 2961, 2962, 9, 11, 2, 2, 2962, 2963, 9, 4, 2, 2, 2963, 2964, 9, 13, 2, 2, 2964, 2965, 9, 14, 2, 2, 2965, 445, 3, 2, 2, 2, 2966, 2967, 9, 7, 2, 2, 2967, 2968, 9, 10, 2, 2, 2968, 2969, 9, 11, 2, 2, 2969, 2970, 9, 9, 2, 2, 2970, 2971, 9, 5, 2, 2, 2971, 2972, 9, 12, 2, 2, 2972, 2973, 9, 6, 2, 2, 2973, 2974, 9, 19, 2, 2, 2974, 447, 3, 2, 2, 2, 2975, 2976, 9, 7, 2, 2, 2976, 2977, 9, 10, 2, 2, 2977, 2978, 9, 27, 2, 2, 2978, 2979, 9, 9, 2, 2, 2979, 2980, 9, 10, 2, 2, 2980, 2981, 9, 13, 2, 2, 2981, 2982, 9, 11, 2, 2, 2982, 2983, 9, 10, 2, 2, 2983, 449, 3, 2, 2, 2, 2984, 2985, 9, 7, 2, 2, 2985, 2986, 9, 10, 2, 2, 2986, 2987, 9, 27, 2, 2, 2987, 2988, 9, 9, 2, 2, 2988, 2989, 9, 10, 2, 2, 2989, 2990, 9, 13, 2, 2, 2990, 2991, 9, 11, 2, 2, 2991, 2992, 9, 10, 2, 2, 2992, 2993, 9, 7, 2, 2, 2993, 451, 3, 2, 2, 2, 2994, 2995, 9, 7, 2, 2, 2995, 2996, 9, 10, 2, 2, 2996, 2997, 9, 5, 2, 2, 2997, 2998, 9, 12, 2, 2, 2998, 2999, 9, 2, 2, 2, 2999, 3000, 9, 8, 2, 2, 3000, 3001, 9, 12, 2, 2, 3001, 3002, 9, 25, 2, 2, 3002, 3003, 9, 2, 2, 2, 3003, 3004, 9, 3, 2, 2, 3004, 3005, 9, 8, 2, 2, 3005, 3006, 9, 10, 2, 2, 3006, 453, 3, 2, 2, 2, 3007, 3008, 9, 7, 2, 2, 3008, 3009, 9, 10, 2, 2, 3009, 3010, 9, 5, 2, 2, 3010, 3011, 9, 23, 2, 2, 3011, 3012, 9, 10, 2, 2, 3012, 3013, 9, 5, 2, 2, 3013, 455, 3, 2, 2, 2, 3014, 3015, 9, 7, 2, 2, 3015, 3016, 9, 10, 2, 2, 3016, 3017, 9, 7, 2, 2, 3017, 3018, 9, 7, 2, 2, 3018, 3019, 9, 12, 2, 2, 3019, 3020, 9, 4, 2, 2, 3020, 3021, 9, 13, 2, 2, 3021, 457, 3, 2, 2, 2, 3022, 3023, 9, 7, 2, 2, 3023, 3024, 9, 10, 2, 2, 3024, 3025, 9, 6, 2, 2, 3025, 459, 3, 2, 2, 2, 3026, 3027, 9, 7, 2, 2, 3027, 3028, 9, 10, 2, 2, 3028, 3029, 9, 6, 2, 2, 3029, 3030, 9, 7, 2, 2, 3030, 461, 3, 2, 2, 2, 3031, 3032, 9, 7, 2, 2, 3032, 3033, 9, 20, 2, 2, 3033, 3034, 9, 2, 2, 2, 3034, 3035, 9, 5, 2, 2, 3035, 3036, 9, 10, 2, 2, 3036, 463, 3, 2, 2, 2, 3037, 3038, 9, 7, 2, 2, 3038, 3039, 9, 20, 2, 2, 3039, 3040, 9, 4, 2, 2, 3040, 3041, 9, 18, 2, 2, 3041, 465, 3, 2, 2, 2, 3042, 3043, 9, 7, 2, 2, 3043, 3044, 9, 12, 2, 2, 3044, 3045, 9, 15, 2, 2, 3045, 3046, 9, 22, 2, 2, 3046, 3047, 9, 8, 2, 2, 3047, 3048, 9, 10, 2, 2, 3048, 467, 3, 2, 2, 2, 3049, 3050, 9, 7, 2, 2, 3050, 3051, 9, 21, 2, 2, 3051, 3052, 9, 12, 2, 2, 3052, 3053, 9, 22, 2, 2, 3053, 469, 3, 2, 2, 2, 3054, 3055, 9, 7, 2, 2, 3055, 3056, 9, 13, 2, 2, 3056, 3057, 9, 2, 2, 2, 3057, 3058, 9, 22, 2, 2, 3058, 3059, 9, 7, 2, 2, 3059, 3060, 9, 20, 2, 2, 3060, 3061, 9, 4, 2, 2, 3061, 3062, 9, 6, 2, 2, 3062, 471, 3, 2, 2, 2, 3063, 3064, 9, 7, 2, 2, 3064, 3065, 9, 27, 2, 2, 3065, 3066, 9, 8, 2, 2, 3066, 473, 3, 2, 2, 2, 3067, 3068, 9, 7, 2, 2, 3068, 3069, 9, 6, 2, 2, 3069, 3070, 9, 2, 2, 2, 3070, 3071, 9, 3, 2, 2, 3071, 3072, 9, 8, 2, 2, 3072, 3073, 9, 10, 2, 2, 3073, 475, 3, 2, 2, 2, 3074, 3075, 9, 7, 2, 2, 3075, 3076, 9, 6, 2, 2, 3076, 3077, 9, 2, 2, 2, 3077, 3078, 9, 13, 2, 2, 3078, 3079, 9, 14, 2, 2, 3079, 3080, 9, 2, 2, 2, 3080, 3081, 9, 8, 2, 2, 3081, 3082, 9, 4, 2, 2, 3082, 3083, 9, 13, 2, 2, 3083, 3084, 9, 10, 2, 2, 3084, 477, 3, 2, 2, 2, 3085, 3086, 9, 7, 2, 2, 3086, 3087, 9, 6, 2, 2, 3087, 3088, 9, 2, 2, 2, 3088, 3089, 9, 5, 2, 2, 3089, 3090, 9, 6, 2, 2, 3090, 479, 3, 2, 2, 2, 3091, 3092, 9, 7, 2, 2, 3092, 3093, 9, 6, 2, 2, 3093, 3094, 9, 2, 2, 2, 3094, 3095, 9, 6, 2, 2, 3095, 3096, 9, 10, 2, 2, 3096, 3097, 9, 15, 2, 2, 3097, 3098, 9, 10, 2, 2, 3098, 3099, 9, 13, 2, 2, 3099, 3100, 9, 6, 2, 2, 3100, 481, 3, 2, 2, 2, 3101, 3102, 9, 7, 2, 2, 3102, 3103, 9, 6, 2, 2, 3103, 3104, 9, 2, 2, 2, 3104, 3105, 9, 6, 2, 2, 3105, 3106, 9, 12, 2, 2, 3106, 3107, 9, 7, 2, 2, 3107, 3108, 9, 6, 2, 2, 3108, 3109, 9, 12, 2, 2, 3109, 3110, 9, 11, 2, 2, 3110, 3111, 9, 7, 2, 2, 3111, 483, 3, 2, 2, 2, 3112, 3113, 9, 7, 2, 2, 3113, 3114, 9, 6, 2, 2, 3114, 3115, 9, 14, 2, 2, 3115, 3116, 9, 12, 2, 2, 3116, 3117, 9, 13, 2, 2, 3117, 485, 3, 2, 2, 2, 3118, 3119, 9, 7, 2, 2, 3119, 3120, 9, 6, 2, 2, 3120, 3121, 9, 14, 2, 2, 3121, 3122, 9, 4, 2, 2, 3122, 3123, 9, 9, 2, 2, 3123, 3124, 9, 6, 2, 2, 3124, 487, 3, 2, 2, 2, 3125, 3126, 9, 7, 2, 2, 3126, 3127, 9, 6, 2, 2, 3127, 3128, 9, 4, 2, 2, 3128, 3129, 9, 5, 2, 2, 3129, 3130, 9, 2, 2, 2, 3130, 3131, 9, 17, 2, 2, 3131, 3132, 9, 10, 2, 2, 3132, 489, 3, 2, 2, 2, 3133, 3134, 9, 7, 2, 2, 3134, 3135, 9, 6, 2, 2, 3135, 3136, 9, 4, 2, 2, 3136, 3137, 9, 5, 2, 2, 3137, 3138, 9, 10, 2, 2, 3138, 3139, 9, 14, 2, 2, 3139, 491, 3, 2, 2, 2, 3140, 3141, 9, 7, 2, 2, 3141, 3142, 9, 6, 2, 2, 3142, 3143, 9, 5, 2, 2, 3143, 3144, 9, 12, 2, 2, 3144, 3145, 9, 11, 2, 2, 3145, 3146, 9, 6, 2, 2, 3146, 493, 3, 2, 2, 2, 3147, 3148, 9, 7, 2, 2, 3148, 3149, 9, 6, 2, 2, 3149, 3150, 9, 5, 2, 2, 3150, 3151, 9, 12, 2, 2, 3151, 3152, 9, 22, 2, 2, 3152, 495, 3, 2, 2, 2, 3153, 3154, 9, 7, 2, 2, 3154, 3155, 9, 9, 2, 2, 3155, 3156, 9, 3, 2, 2, 3156, 3157, 9, 7, 2, 2, 3157, 3158, 9, 11, 2, 2, 3158, 3159, 9, 5, 2, 2, 3159, 3160, 9, 12, 2, 2, 3160, 3161, 9, 22, 2, 2, 3161, 3162, 9, 6, 2, 2, 3162, 3163, 9, 12, 2, 2, 3163, 3164, 9, 4, 2, 2, 3164, 3165, 9, 13, 2, 2, 3165, 497, 3, 2, 2, 2, 3166, 3167, 9, 7, 2, 2, 3167, 3168, 9, 9, 2, 2, 3168, 3169, 9, 22, 2, 2, 3169, 3170, 9, 22, 2, 2, 3170, 3171, 9, 4, 2, 2, 3171, 3172, 9, 5, 2, 2, 3172, 3173, 9, 6, 2, 2, 3173, 499, 3, 2, 2, 2, 3174, 3175, 9, 7, 2, 2, 3175, 3176, 9, 19, 2, 2, 3176, 3177, 9, 7, 2, 2, 3177, 3178, 9, 12, 2, 2, 3178, 3179, 9, 14, 2, 2, 3179, 501, 3, 2, 2, 2, 3180, 3181, 9, 7, 2, 2, 3181, 3182, 9, 19, 2, 2, 3182, 3183, 9, 7, 2, 2, 3183, 3184, 9, 6, 2, 2, 3184, 3185, 9, 10, 2, 2, 3185, 3186, 9, 15, 2, 2, 3186, 503, 3, 2, 2, 2, 3187, 3188, 9, 6, 2, 2, 3188, 3189, 9, 2, 2, 2, 3189, 3190, 9, 3, 2, 2, 3190, 3191, 9, 8, 2, 2, 3191, 3192, 9, 10, 2, 2, 3192, 3193, 9, 7, 2, 2, 3193, 505, 3, 2, 2, 2, 3194, 3195, 9, 6, 2, 2, 3195, 3196, 9, 2, 2, 2, 3196, 3197, 9, 3, 2, 2, 3197, 3198, 9, 8, 2, 2, 3198, 3199, 9, 10, 2, 2, 3199, 3200, 9, 7, 2, 2, 3200, 3201, 9, 22, 2, 2, 3201, 3202, 9, 2, 2, 2, 3202, 3203, 9, 11, 2, 2, 3203, 3204, 9, 10, 2, 2, 3204, 507, 3, 2, 2, 2, 3205, 3206, 9, 6, 2, 2, 3206, 3207, 9, 10, 2, 2, 3207, 3208, 9, 15, 2, 2, 3208, 3209, 9, 22, 2, 2, 3209, 509, 3, 2, 2, 2, 3210, 3211, 9, 6, 2, 2, 3211, 3212, 9, 10, 2, 2, 3212, 3213, 9, 15, 2, 2, 3213, 3214, 9, 22, 2, 2, 3214, 3215, 9, 8, 2, 2, 3215, 3216, 9, 2, 2, 2, 3216, 3217, 9, 6, 2, 2, 3217, 3218, 9, 10, 2, 2, 3218, 511, 3, 2, 2, 2, 3219, 3220, 9, 6, 2, 2, 3220, 3221, 9, 10, 2, 2, 3221, 3222, 9, 15, 2, 2, 3222, 3223, 9, 22, 2, 2, 3223, 3224, 9, 4, 2, 2, 3224, 3225, 9, 5, 2, 2, 3225, 3226, 9, 2, 2, 2, 3226, 3227, 9, 5, 2, 2, 3227, 3228, 9, 19, 2, 2, 3228, 513, 3, 2, 2, 2, 3229, 3230, 9, 6, 2, 2, 3230, 3231, 9, 10, 2, 2, 3231, 3232, 9, 24, 2, 2, 3232, 3233, 9, 6, 2, 2, 3233, 515, 3, 2, 2, 2, 3234, 3235, 9, 6, 2, 2, 3235, 3236, 9, 12, 2, 2, 3236, 3237, 9, 10, 2, 2, 3237, 3238, 9, 7, 2, 2, 3238, 517, 3, 2, 2, 2, 3239, 3240, 9, 6, 2, 2, 3240, 3241, 9, 5, 2, 2, 3241, 3242, 9, 2, 2, 2, 3242, 3243, 9, 13, 2, 2, 3243, 3244, 9, 7, 2, 2, 3244, 3245, 9, 2, 2, 2, 3245, 3246, 9, 11, 2, 2, 3246, 3247, 9, 6, 2, 2, 3247, 3248, 9, 12, 2, 2, 3248, 3249, 9, 4, 2, 2, 3249, 3250, 9, 13, 2, 2, 3250, 519, 3, 2, 2, 2, 3251, 3252, 9, 6, 2, 2, 3252, 3253, 9, 5, 2, 2, 3253, 3254, 9, 2, 2, 2, 3254, 3255, 9, 13, 2, 2, 3255, 3256, 9, 7, 2, 2, 3256, 3257, 9, 16, 2, 2, 3257, 3258, 9, 4, 2, 2, 3258, 3259, 9, 5, 2, 2, 3259, 3260, 9, 15, 2, 2, 3260, 521, 3, 2, 2, 2, 3261, 3262, 9, 6, 2, 2, 3262, 3263, 9, 5, 2, 2, 3263, 3264, 9, 12, 2, 2, 3264, 3265, 9, 17, 2, 2, 3265, 3266, 9, 17, 2, 2, 3266, 3267, 9, 10, 2, 2, 3267, 3268, 9, 5, 2, 2, 3268, 523, 3, 2, 2, 2, 3269, 3270, 9, 6, 2, 2, 3270, 3271, 9, 5, 2, 2, 3271, 3272, 9, 9, 2, 2, 3272, 3273, 9, 13, 2, 2, 3273, 3274, 9, 11, 2, 2, 3274, 3275, 9, 2, 2, 2, 3275, 3276, 9, 6, 2, 2, 3276, 3277, 9, 10, 2, 2, 3277, 525, 3, 2, 2, 2, 3278, 3279, 9, 6, 2, 2, 3279, 3280, 9, 5, 2, 2, 3280, 3281, 9, 9, 2, 2, 3281, 3282, 9, 7, 2, 2, 3282, 3283, 9, 6, 2, 2, 3283, 3284, 9, 10, 2, 2, 3284, 3285, 9, 14, 2, 2, 3285, 527, 3, 2, 2, 2, 3286, 3287, 9, 6, 2, 2, 3287, 3288, 9, 19, 2, 2, 3288, 3289, 9, 22, 2, 2, 3289, 3290, 9, 10, 2, 2, 3290, 529, 3, 2, 2, 2, 3291, 3292, 9, 6, 2, 2, 3292, 3293, 9, 19, 2, 2, 3293, 3294, 9, 22, 2, 2, 3294, 3295, 9, 10, 2, 2, 3295, 3296, 9, 7, 2, 2, 3296, 531, 3, 2, 2, 2, 3297, 3298, 9, 9, 2, 2, 3298, 3299, 9, 13, 2, 2, 3299, 3300, 9, 3, 2, 2, 3300, 3301, 9, 4, 2, 2, 3301, 3302, 9, 9, 2, 2, 3302, 3303, 9, 13, 2, 2, 3303, 3304, 9, 14, 2, 2, 3304, 3305, 9, 10, 2, 2, 3305, 3306, 9, 14, 2, 2, 3306, 533, 3, 2, 2, 2, 3307, 3308, 9, 9, 2, 2, 3308, 3309, 9, 13, 2, 2, 3309, 3310, 9, 11, 2, 2, 3310, 3311, 9, 4, 2, 2, 3311, 3312, 9, 15, 2, 2, 3312, 3313, 9, 15, 2, 2, 3313, 3314, 9, 12, 2, 2, 3314, 3315, 9, 6, 2, 2, 3315, 3316, 9, 6, 2, 2, 3316, 3317, 9, 10, 2, 2, 3317, 3318, 9, 14, 2, 2, 3318, 535, 3, 2, 2, 2, 3319, 3320, 9, 9, 2, 2, 3320, 3321, 9, 13, 2, 2, 3321, 3322, 9, 10, 2, 2, 3322, 3323, 9, 13, 2, 2, 3323, 3324, 9, 11, 2, 2, 3324, 3325, 9, 5, 2, 2, 3325, 3326, 9, 19, 2, 2, 3326, 3327, 9, 22, 2, 2, 3327, 3328, 9, 6, 2, 2, 3328, 3329, 9, 10, 2, 2, 3329, 3330, 9, 14, 2, 2, 3330, 537, 3, 2, 2, 2, 3331, 3332, 9, 9, 2, 2, 3332, 3333, 9, 13, 2, 2, 3333, 3334, 9, 21, 2, 2, 3334, 3335, 9, 13, 2, 2, 3335, 3336, 9, 4, 2, 2, 3336, 3337, 9, 18, 2, 2, 3337, 3338, 9, 13, 2, 2, 3338, 539, 3, 2, 2, 2, 3339, 3340, 9, 9, 2, 2, 3340, 3341, 9, 13, 2, 2, 3341, 3342, 9, 8, 2, 2, 3342, 3343, 9, 12, 2, 2, 3343, 3344, 9, 7, 2, 2, 3344, 3345, 9, 6, 2, 2, 3345, 3346, 9, 10, 2, 2, 3346, 3347, 9, 13, 2, 2, 3347, 541, 3, 2, 2, 2, 3348, 3349, 9, 9, 2, 2, 3349, 3350, 9, 13, 2, 2, 3350, 3351, 9, 8, 2, 2, 3351, 3352, 9, 4, 2, 2, 3352, 3353, 9, 17, 2, 2, 3353, 3354, 9, 17, 2, 2, 3354, 3355, 9, 10, 2, 2, 3355, 3356, 9, 14, 2, 2, 3356, 543, 3, 2, 2, 2, 3357, 3358, 9, 9, 2, 2, 3358, 3359, 9, 13, 2, 2, 3359, 3360, 9, 6, 2, 2, 3360, 3361, 9, 12, 2, 2, 3361, 3362, 9, 8, 2, 2, 3362, 545, 3, 2, 2, 2, 3363, 3364, 9, 9, 2, 2, 3364, 3365, 9, 22, 2, 2, 3365, 3366, 9, 14, 2, 2, 3366, 3367, 9, 2, 2, 2, 3367, 3368, 9, 6, 2, 2, 3368, 3369, 9, 10, 2, 2, 3369, 547, 3, 2, 2, 2, 3370, 3371, 9, 23, 2, 2, 3371, 3372, 9, 2, 2, 2, 3372, 3373, 9, 11, 2, 2, 3373, 3374, 9, 9, 2, 2, 3374, 3375, 9, 9, 2, 2, 3375, 3376, 9, 15, 2, 2, 3376, 549, 3, 2, 2, 2, 3377, 3378, 9, 23, 2, 2, 3378, 3379, 9, 2, 2, 2, 3379, 3380, 9, 8, 2, 2, 3380, 3381, 9, 12, 2, 2, 3381, 3382, 9, 14, 2, 2, 3382, 551, 3, 2, 2, 2, 3383, 3384, 9, 23, 2, 2, 3384, 3385, 9, 2, 2, 2, 3385, 3386, 9, 8, 2, 2, 3386, 3387, 9, 12, 2, 2, 3387, 3388, 9, 14, 2, 2, 3388, 3389, 9, 2, 2, 2, 3389, 3390, 9, 6, 2, 2, 3390, 3391, 9, 10, 2, 2, 3391, 553, 3, 2, 2, 2, 3392, 3393, 9, 23, 2, 2, 3393, 3394, 9, 2, 2, 2, 3394, 3395, 9, 8, 2, 2, 3395, 3396, 9, 12, 2, 2, 3396, 3397, 9, 14, 2, 2, 3397, 3398, 9, 2, 2, 2, 3398, 3399, 9, 6, 2, 2, 3399, 3400, 9, 4, 2, 2, 3400, 3401, 9, 5, 2, 2, 3401, 555, 3, 2, 2, 2, 3402, 3403, 9, 23, 2, 2, 3403, 3404, 9, 2, 2, 2, 3404, 3405, 9, 8, 2, 2, 3405, 3406, 9, 9, 2, 2, 3406, 3407, 9, 10, 2, 2, 3407, 557, 3, 2, 2, 2, 3408, 3409, 9, 23, 2, 2, 3409, 3410, 9, 2, 2, 2, 3410, 3411, 9, 5, 2, 2, 3411, 3412, 9, 19, 2, 2, 3412, 3413, 9, 12, 2, 2, 3413, 3414, 9, 13, 2, 2, 3414, 3415, 9, 17, 2, 2, 3415, 559, 3, 2, 2, 2, 3416, 3417, 9, 23, 2, 2, 3417, 3418, 9, 10, 2, 2, 3418, 3419, 9, 5, 2, 2, 3419, 3420, 9, 7, 2, 2, 3420, 3421, 9, 12, 2, 2, 3421, 3422, 9, 4, 2, 2, 3422, 3423, 9, 13, 2, 2, 3423, 561, 3, 2, 2, 2, 3424, 3425, 9, 23, 2, 2, 3425, 3426, 9, 12, 2, 2, 3426, 3427, 9, 10, 2, 2, 3427, 3428, 9, 18, 2, 2, 3428, 563, 3, 2, 2, 2, 3429, 3430, 9, 23, 2, 2, 3430, 3431, 9, 12, 2, 2, 3431, 3432, 9, 10, 2, 2, 3432, 3433, 9, 18, 2, 2, 3433, 3434, 9, 7, 2, 2, 3434, 565, 3, 2, 2, 2, 3435, 3436, 9, 23, 2, 2, 3436, 3437, 9, 4, 2, 2, 3437, 3438, 9, 8, 2, 2, 3438, 3439, 9, 2, 2, 2, 3439, 3440, 9, 6, 2, 2, 3440, 3441, 9, 12, 2, 2, 3441, 3442, 9, 8, 2, 2, 3442, 3443, 9, 10, 2, 2, 3443, 567, 3, 2, 2, 2, 3444, 3445, 9, 18, 2, 2, 3445, 3446, 9, 20, 2, 2, 3446, 3447, 9, 12, 2, 2, 3447, 3448, 9, 6, 2, 2, 3448, 3449, 9, 10, 2, 2, 3449, 3450, 9, 7, 2, 2, 3450, 3451, 9, 22, 2, 2, 3451, 3452, 9, 2, 2, 2, 3452, 3453, 9, 11, 2, 2, 3453, 3454, 9, 10, 2, 2, 3454, 569, 3, 2, 2, 2, 3455, 3456, 9, 18, 2, 2, 3456, 3457, 9, 12, 2, 2, 3457, 3458, 9, 6, 2, 2, 3458, 3459, 9, 20, 2, 2, 3459, 3460, 9, 12, 2, 2, 3460, 3461, 9, 13, 2, 2, 3461, 571, 3, 2, 2, 2, 3462, 3463, 9, 18, 2, 2, 3463, 3464, 9, 12, 2, 2, 3464, 3465, 9, 6, 2, 2, 3465, 3466, 9, 20, 2, 2, 3466, 3467, 9, 4, 2, 2, 3467, 3468, 9, 9, 2, 2, 3468, 3469, 9, 6, 2, 2, 3469, 573, 3, 2, 2, 2, 3470, 3471, 9, 18, 2, 2, 3471, 3472, 9, 4, 2, 2, 3472, 3473, 9, 5, 2, 2, 3473, 3474, 9, 21, 2, 2, 3474, 575, 3, 2, 2, 2, 3475, 3476, 9, 18, 2, 2, 3476, 3477, 9, 5, 2, 2, 3477, 3478, 9, 2, 2, 2, 3478, 3479, 9, 22, 2, 2, 3479, 3480, 9, 22, 2, 2, 3480, 3481, 9, 10, 2, 2, 3481, 3482, 9, 5, 2, 2, 3482, 577, 3, 2, 2, 2, 3483, 3484, 9, 18, 2, 2, 3484, 3485, 9, 5, 2, 2, 3485, 3486, 9, 12, 2, 2, 3486, 3487, 9, 6, 2, 2, 3487, 3488, 9, 10, 2, 2, 3488, 579, 3, 2, 2, 2, 3489, 3490, 9, 24, 2, 2, 3490, 3491, 9, 15, 2, 2, 3491, 3492, 9, 8, 2, 2, 3492, 581, 3, 2, 2, 2, 3493, 3494, 9, 19, 2, 2, 3494, 3495, 9, 10, 2, 2, 3495, 3496, 9, 2, 2, 2, 3496, 3497, 9, 5, 2, 2, 3497, 583, 3, 2, 2, 2, 3498, 3499, 9, 19, 2, 2, 3499, 3500, 9, 10, 2, 2, 3500, 3501, 9, 7, 2, 2, 3501, 585, 3, 2, 2, 2, 3502, 3503, 9, 25, 2, 2, 3503, 3504, 9, 4, 2, 2, 3504, 3505, 9, 13, 2, 2, 3505, 3506, 9, 10, 2, 2, 3506, 587, 3, 2, 2, 2, 3507, 3508, 9, 3, 2, 2, 3508, 3509, 9, 10, 2, 2, 3509, 3510, 9, 6, 2, 2, 3510, 3511, 9, 18, 2, 2, 3511, 3512, 9, 10, 2, 2, 3512, 3513, 9, 10, 2, 2, 3513, 3514, 9, 13, 2, 2, 3514, 589, 3, 2, 2, 2, 3515, 3516, 9, 3, 2, 2, 3516, 3517, 9, 12, 2, 2, 3517, 3518, 9, 17, 2, 2, 3518, 3519, 9, 12, 2, 2, 3519, 3520, 9, 13, 2, 2, 3520, 3521, 9, 6, 2, 2, 3521, 591, 3, 2, 2, 2, 3522, 3523, 9, 3, 2, 2, 3523, 3524, 9, 12, 2, 2, 3524, 3525, 9, 6, 2, 2, 3525, 593, 3, 2, 2, 2, 3526, 3527, 9, 3, 2, 2, 3527, 3528, 9, 4, 2, 2, 3528, 3529, 9, 4, 2, 2, 3529, 3530, 9, 8, 2, 2, 3530, 3531, 9, 10, 2, 2, 3531, 3532, 9, 2, 2, 2, 3532, 3533, 9, 13, 2, 2, 3533, 595, 3, 2, 2, 2, 3534, 3535, 9, 11, 2, 2, 3535, 3536, 9, 20, 2, 2, 3536, 3537, 9, 2, 2, 2, 3537, 3538, 9, 5, 2, 2, 3538, 597, 3, 2, 2, 2, 3539, 3540, 9, 11, 2, 2, 3540, 3541, 9, 20, 2, 2, 3541, 3542, 9, 2, 2, 2, 3542, 3543, 9, 5, 2, 2, 3543, 3544, 9, 2, 2, 2, 3544, 3545, 9, 11, 2, 2, 3545, 3546, 9, 6, 2, 2, 3546, 3547, 9, 10, 2, 2, 3547, 3548, 9, 5, 2, 2, 3548, 599, 3, 2, 2, 2, 3549, 3550, 9, 11, 2, 2, 3550, 3551, 9, 4, 2, 2, 3551, 3552, 9, 2, 2, 2, 3552, 3553, 9, 8, 2, 2, 3553, 3554, 9, 10, 2, 2, 3554, 3555, 9, 7, 2, 2, 3555, 3556, 9, 11, 2, 2, 3556, 3557, 9, 10, 2, 2, 3557, 601, 3, 2, 2, 2, 3558, 3559, 9, 14, 2, 2, 3559, 3560, 9, 10, 2, 2, 3560, 3561, 9, 11, 2, 2, 3561, 603, 3, 2, 2, 2, 3562, 3563, 9, 14, 2, 2, 3563, 3564, 9, 10, 2, 2, 3564, 3565, 9, 11, 2, 2, 3565, 3566, 9, 12, 2, 2, 3566, 3567, 9, 15, 2, 2, 3567, 3568, 9, 2, 2, 2, 3568, 3569, 9, 8, 2, 2, 3569, 605, 3, 2, 2, 2, 3570, 3571, 9, 10, 2, 2, 3571, 3572, 9, 24, 2, 2, 3572, 3573, 9, 12, 2, 2, 3573, 3574, 9, 7, 2, 2, 3574, 3575, 9, 6, 2, 2, 3575, 3576, 9, 7, 2, 2, 3576, 607, 3, 2, 2, 2, 3577, 3578, 9, 10, 2, 2, 3578, 3579, 9, 24, 2, 2, 3579, 3580, 9, 6, 2, 2, 3580, 3581, 9, 5, 2, 2, 3581, 3582, 9, 2, 2, 2, 3582, 3583, 9, 11, 2, 2, 3583, 3584, 9, 6, 2, 2, 3584, 609, 3, 2, 2, 2, 3585, 3586, 9, 16, 2, 2, 3586, 3587, 9, 8, 2, 2, 3587, 3588, 9, 4, 2, 2, 3588, 3589, 9, 2, 2, 2, 3589, 3590, 9, 6, 2, 2, 3590, 611, 3, 2, 2, 2, 3591, 3592, 9, 17, 2, 2, 3592, 3593, 9, 5, 2, 2, 3593, 3594, 9, 10, 2, 2, 3594, 3595, 9, 2, 2, 2, 3595, 3596, 9, 6, 2, 2, 3596, 3597, 9, 10, 2, 2, 3597, 3598, 9, 7, 2, 2, 3598, 3599, 9, 6, 2, 2, 3599, 613, 3, 2, 2, 2, 3600, 3601, 9, 17, 2, 2, 3601, 3602, 9, 5, 2, 2, 3602, 3603, 9, 4, 2, 2, 3603, 3604, 9, 9, 2, 2, 3604, 3605, 9, 22, 2, 2, 3605, 3606, 9, 12, 2, 2, 3606, 3607, 9, 13, 2, 2, 3607, 3608, 9, 17, 2, 2, 3608, 615, 3, 2, 2, 2, 3609, 3610, 9, 12, 2, 2, 3610, 3611, 9, 13, 2, 2, 3611, 3612, 9, 4, 2, 2, 3612, 3613, 9, 9, 2, 2, 3613, 3614, 9, 6, 2, 2, 3614, 617, 3, 2, 2, 2, 3615, 3616, 9, 12, 2, 2, 3616, 3617, 9, 13, 2, 2, 3617, 3618, 9, 6, 2, 2, 3618, 619, 3, 2, 2, 2, 3619, 3620, 9, 12, 2, 2, 3620, 3621, 9, 13, 2, 2, 3621, 3622, 9, 6, 2, 2, 3622, 3623, 9, 10, 2, 2, 3623, 3624, 9, 17, 2, 2, 3624, 3625, 9, 10, 2, 2, 3625, 3626, 9, 5, 2, 2, 3626, 621, 3, 2, 2, 2, 3627, 3628, 9, 12, 2, 2, 3628, 3629, 9, 13, 2, 2, 3629, 3630, 9, 6, 2, 2, 3630, 3631, 9, 10, 2, 2, 3631, 3632, 9, 5, 2, 2, 3632, 3633, 9, 23, 2, 2, 3633, 3634, 9, 2, 2, 2, 3634, 3635, 9, 8, 2, 2, 3635, 623, 3, 2, 2, 2, 3636, 3637, 9, 8, 2, 2, 3637, 3638, 9, 10, 2, 2, 3638, 3639, 9, 2, 2, 2, 3639, 3640, 9, 7, 2, 2, 3640, 3641, 9, 6, 2, 2, 3641, 625, 3, 2, 2, 2, 3642, 3643, 9, 13, 2, 2, 3643, 3644, 9, 2, 2, 2, 3644, 3645, 9, 6, 2, 2, 3645, 3646, 9, 12, 2, 2, 3646, 3647, 9, 4, 2, 2, 3647, 3648, 9, 13, 2, 2, 3648, 3649, 9, 2, 2, 2, 3649, 3650, 9, 8, 2, 2, 3650, 627, 3, 2, 2, 2, 3651, 3652, 9, 13, 2, 2, 3652, 3653, 9, 11, 2, 2, 3653, 3654, 9, 20, 2, 2, 3654, 3655, 9, 2, 2, 2, 3655, 3656, 9, 5, 2, 2, 3656, 629, 3, 2, 2, 2, 3657, 3658, 9, 13, 2, 2, 3658, 3659, 9, 4, 2, 2, 3659, 3660, 9, 13, 2, 2, 3660, 3661, 9, 10, 2, 2, 3661, 631, 3, 2, 2, 2, 3662, 3663, 9, 13, 2, 2, 3663, 3664, 9, 9, 2, 2, 3664, 3665, 9, 8, 2, 2, 3665, 3666, 9, 8, 2, 2, 3666, 3667, 9, 12, 2, 2, 3667, 3668, 9, 16, 2, 2, 3668, 633, 3, 2, 2, 2, 3669, 3670, 9, 13, 2, 2, 3670, 3671, 9, 9, 2, 2, 3671, 3672, 9, 15, 2, 2, 3672, 3673, 9, 10, 2, 2, 3673, 3674, 9, 5, 2, 2, 3674, 3675, 9, 12, 2, 2, 3675, 3676, 9, 11, 2, 2, 3676, 635, 3, 2, 2, 2, 3677, 3678, 9, 4, 2, 2, 3678, 3679, 9, 9, 2, 2, 3679, 3680, 9, 6, 2, 2, 3680, 637, 3, 2, 2, 2, 3681, 3682, 9, 4, 2, 2, 3682, 3683, 9, 23, 2, 2, 3683, 3684, 9, 10, 2, 2, 3684, 3685, 9, 5, 2, 2, 3685, 3686, 9, 8, 2, 2, 3686, 3687, 9, 2, 2, 2, 3687, 3688, 9, 19, 2, 2, 3688, 639, 3, 2, 2, 2, 3689, 3690, 9, 22, 2, 2, 3690, 3691, 9, 4, 2, 2, 3691, 3692, 9, 7, 2, 2, 3692, 3693, 9, 12, 2, 2, 3693, 3694, 9, 6, 2, 2, 3694, 3695, 9, 12, 2, 2, 3695, 3696, 9, 4, 2, 2, 3696, 3697, 9, 13, 2, 2, 3697, 641, 3, 2, 2, 2, 3698, 3699, 9, 22, 2, 2, 3699, 3700, 9, 5, 2, 2, 3700, 3701, 9, 10, 2, 2, 3701, 3702, 9, 11, 2, 2, 3702, 3703, 9, 12, 2, 2, 3703, 3704, 9, 7, 2, 2, 3704, 3705, 9, 12, 2, 2, 3705, 3706, 9, 4, 2, 2, 3706, 3707, 9, 13, 2, 2, 3707, 643, 3, 2, 2, 2, 3708, 3709, 9, 5, 2, 2, 3709, 3710, 9, 10, 2, 2, 3710, 3711, 9, 2, 2, 2, 3711, 3712, 9, 8, 2, 2, 3712, 645, 3, 2, 2, 2, 3713, 3714, 9, 5, 2, 2, 3714, 3715, 9, 4, 2, 2, 3715, 3716, 9, 18, 2, 2, 3716, 647, 3, 2, 2, 2, 3717, 3718, 9, 7, 2, 2, 3718, 3719, 9, 10, 2, 2, 3719, 3720, 9, 6, 2, 2, 3720, 3721, 9, 4, 2, 2, 3721, 3722, 9, 16, 2, 2, 3722, 649, 3, 2, 2, 2, 3723, 3724, 9, 7, 2, 2, 3724, 3725, 9, 15, 2, 2, 3725, 3726, 9, 2, 2, 2, 3726, 3727, 9, 8, 2, 2, 3727, 3728, 9, 8, 2, 2, 3728, 3729, 9, 12, 2, 2, 3729, 3730, 9, 13, 2, 2, 3730, 3731, 9, 6, 2, 2, 3731, 651, 3, 2, 2, 2, 3732, 3733, 9, 7, 2, 2, 3733, 3734, 9, 9, 2, 2, 3734, 3735, 9, 3, 2, 2, 3735, 3736, 9, 7, 2, 2, 3736, 3737, 9, 6, 2, 2, 3737, 3738, 9, 5, 2, 2, 3738, 3739, 9, 12, 2, 2, 3739, 3740, 9, 13, 2, 2, 3740, 3741, 9, 17, 2, 2, 3741, 653, 3, 2, 2, 2, 3742, 3743, 9, 6, 2, 2, 3743, 3744, 9, 12, 2, 2, 3744, 3745, 9, 15, 2, 2, 3745, 3746, 9, 10, 2, 2, 3746, 655, 3, 2, 2, 2, 3747, 3748, 9, 6, 2, 2, 3748, 3749, 9, 12, 2, 2, 3749, 3750, 9, 15, 2, 2, 3750, 3751, 9, 10, 2, 2, 3751, 3752, 9, 7, 2, 2, 3752, 3753, 9, 6, 2, 2, 3753, 3754, 9, 2, 2, 2, 3754, 3755, 9, 15, 2, 2, 3755, 3756, 9, 22, 2, 2, 3756, 657, 3, 2, 2, 2, 3757, 3758, 9, 6, 2, 2, 3758, 3759, 9, 5, 2, 2, 3759, 3760, 9, 10, 2, 2, 3760, 3761, 9, 2, 2, 2, 3761, 3762, 9, 6, 2, 2, 3762, 659, 3, 2, 2, 2, 3763, 3764, 9, 6, 2, 2, 3764, 3765, 9, 5, 2, 2, 3765, 3766, 9, 12, 2, 2, 3766, 3767, 9, 15, 2, 2, 3767, 661, 3, 2, 2, 2, 3768, 3769, 9, 23, 2, 2, 3769, 3770, 9, 2, 2, 2, 3770, 3771, 9, 8, 2, 2, 3771, 3772, 9, 9, 2, 2, 3772, 3773, 9, 10, 2, 2, 3773, 3774, 9, 7, 2, 2, 3774, 663, 3, 2, 2, 2, 3775, 3776, 9, 23, 2, 2, 3776, 3777, 9, 2, 2, 2, 3777, 3778, 9, 5, 2, 2, 3778, 3779, 9, 11, 2, 2, 3779, 3780, 9, 20, 2, 2, 3780, 3781, 9, 2, 2, 2, 3781, 3782, 9, 5, 2, 2, 3782, 665, 3, 2, 2, 2, 3783, 3784, 9, 24, 2, 2, 3784, 3785, 9, 15, 2, 2, 3785, 3786, 9, 8, 2, 2, 3786, 3787, 9, 2, 2, 2, 3787, 3788, 9, 6, 2, 2, 3788, 3789, 9, 6, 2, 2, 3789, 3790, 9, 5, 2, 2, 3790, 3791, 9, 12, 2, 2, 3791, 3792, 9, 3, 2, 2, 3792, 3793, 9, 9, 2, 2, 3793, 3794, 9, 6, 2, 2, 3794, 3795, 9, 10, 2, 2, 3795, 3796, 9, 7, 2, 2, 3796, 667, 3, 2, 2, 2, 3797, 3798, 9, 24, 2, 2, 3798, 3799, 9, 15, 2, 2, 3799, 3800, 9, 8, 2, 2, 3800, 3801, 9, 11, 2, 2, 3801, 3802, 9, 4, 2, 2, 3802, 3803, 9, 13, 2, 2, 3803, 3804, 9, 11, 2, 2, 3804, 3805, 9, 2, 2, 2, 3805, 3806, 9, 6, 2, 2, 3806, 669, 3, 2, 2, 2, 3807, 3808, 9, 24, 2, 2, 3808, 3809, 9, 15, 2, 2, 3809, 3810, 9, 8, 2, 2, 3810, 3811, 9, 10, 2, 2, 3811, 3812, 9, 8, 2, 2, 3812, 3813, 9, 10, 2, 2, 3813, 3814, 9, 15, 2, 2, 3814, 3815, 9, 10, 2, 2, 3815, 3816, 9, 13, 2, 2, 3816, 3817, 9, 6, 2, 2, 3817, 671, 3, 2, 2, 2, 3818, 3819, 9, 24, 2, 2, 3819, 3820, 9, 15, 2, 2, 3820, 3821, 9, 8, 2, 2, 3821, 3822, 9, 10, 2, 2, 3822, 3823, 9, 24, 2, 2, 3823, 3824, 9, 12, 2, 2, 3824, 3825, 9, 7, 2, 2, 3825, 3826, 9, 6, 2, 2, 3826, 3827, 9, 7, 2, 2, 3827, 673, 3, 2, 2, 2, 3828, 3829, 9, 24, 2, 2, 3829, 3830, 9, 15, 2, 2, 3830, 3831, 9, 8, 2, 2, 3831, 3832, 9, 16, 2, 2, 3832, 3833, 9, 4, 2, 2, 3833, 3834, 9, 5, 2, 2, 3834, 3835, 9, 10, 2, 2, 3835, 3836, 9, 7, 2, 2, 3836, 3837, 9, 6, 2, 2, 3837, 675, 3, 2, 2, 2, 3838, 3839, 9, 24, 2, 2, 3839, 3840, 9, 15, 2, 2, 3840, 3841, 9, 8, 2, 2, 3841, 3842, 9, 13, 2, 2, 3842, 3843, 9, 2, 2, 2, 3843, 3844, 9, 15, 2, 2, 3844, 3845, 9, 10, 2, 2, 3845, 3846, 9, 7, 2, 2, 3846, 3847, 9, 22, 2, 2, 3847, 3848, 9, 2, 2, 2, 3848, 3849, 9, 11, 2, 2, 3849, 3850, 9, 10, 2, 2, 3850, 3851, 9, 7, 2, 2, 3851, 677, 3, 2, 2, 2, 3852, 3853, 9, 24, 2, 2, 3853, 3854, 9, 15, 2, 2, 3854, 3855, 9, 8, 2, 2, 3855, 3856, 9, 22, 2, 2, 3856, 3857, 9, 2, 2, 2, 3857, 3858, 9, 5, 2, 2, 3858, 3859, 9, 7, 2, 2, 3859, 3860, 9, 10, 2, 2, 3860, 679, 3, 2, 2, 2, 3861, 3862, 9, 24, 2, 2, 3862, 3863, 9, 15, 2, 2, 3863, 3864, 9, 8, 2, 2, 3864, 3865, 9, 22, 2, 2, 3865, 3866, 9, 12, 2, 2, 3866, 681, 3, 2, 2, 2, 3867, 3868, 9, 24, 2, 2, 3868, 3869, 9, 15, 2, 2, 3869, 3870, 9, 8, 2, 2, 3870, 3871, 9, 5, 2, 2, 3871, 3872, 9, 4, 2, 2, 3872, 3873, 9, 4, 2, 2, 3873, 3874, 9, 6, 2, 2, 3874, 683, 3, 2, 2, 2, 3875, 3876, 9, 24, 2, 2, 3876, 3877, 9, 15, 2, 2, 3877, 3878, 9, 8, 2, 2, 3878, 3879, 9, 7, 2, 2, 3879, 3880, 9, 10, 2, 2, 3880, 3881, 9, 5, 2, 2, 3881, 3882, 9, 12, 2, 2, 3882, 3883, 9, 2, 2, 2, 3883, 3884, 9, 8, 2, 2, 3884, 3885, 9, 12, 2, 2, 3885, 3886, 9, 25, 2, 2, 3886, 3887, 9, 10, 2, 2, 3887, 685, 3, 2, 2, 2, 3888, 3889, 9, 24, 2, 2, 3889, 3890, 9, 15, 2, 2, 3890, 3891, 9, 8, 2, 2, 3891, 3892, 9, 6, 2, 2, 3892, 3893, 9, 2, 2, 2, 3893, 3894, 9, 3, 2, 2, 3894, 3895, 9, 8, 2, 2, 3895, 3896, 9, 10, 2, 2, 3896, 687, 3, 2, 2, 2, 3897, 3898, 9, 2, 2, 2, 3898, 3899, 9, 9, 2, 2, 3899, 3900, 9, 6, 2, 2, 3900, 3901, 9, 20, 2, 2, 3901, 3902, 9, 4, 2, 2, 3902, 3903, 9, 5, 2, 2, 3903, 3904, 9, 12, 2, 2, 3904, 3905, 9, 25, 2, 2, 3905, 3906, 9, 2, 2, 2, 3906, 3907, 9, 6, 2, 2, 3907, 3908, 9, 12, 2, 2, 3908, 3909, 9, 4, 2, 2, 3909, 3910, 9, 13, 2, 2, 3910, 689, 3, 2, 2, 2, 3911, 3912, 9, 3, 2, 2, 3912, 3913, 9, 12, 2, 2, 3913, 3914, 9, 13, 2, 2, 3914, 3915, 9, 2, 2, 2, 3915, 3916, 9, 5, 2, 2, 3916, 3917, 9, 19, 2, 2, 3917, 691, 3, 2, 2, 2, 3918, 3919, 9, 11, 2, 2, 3919, 3920, 9, 4, 2, 2, 3920, 3921, 9, 8, 2, 2, 3921, 3922, 9, 8, 2, 2, 3922, 3923, 9, 2, 2, 2, 3923, 3924, 9, 6, 2, 2, 3924, 3925, 9, 12, 2, 2, 3925, 3926, 9, 4, 2, 2, 3926, 3927, 9, 13, 2, 2, 3927, 693, 3, 2, 2, 2, 3928, 3929, 9, 11, 2, 2, 3929, 3930, 9, 4, 2, 2, 3930, 3931, 9, 13, 2, 2, 3931, 3932, 9, 11, 2, 2, 3932, 3933, 9, 9, 2, 2, 3933, 3934, 9, 5, 2, 2, 3934, 3935, 9, 5, 2, 2, 3935, 3936, 9, 10, 2, 2, 3936, 3937, 9, 13, 2, 2, 3937, 3938, 9, 6, 2, 2, 3938, 3939, 9, 8, 2, 2, 3939, 3940, 9, 19, 2, 2, 3940, 695, 3, 2, 2, 2, 3941, 3942, 9, 11, 2, 2, 3942, 3943, 9, 5, 2, 2, 3943, 3944, 9, 4, 2, 2, 3944, 3945, 9, 7, 2, 2, 3945, 3946, 9, 7, 2, 2, 3946, 697, 3, 2, 2, 2, 3947, 3948, 9, 11, 2, 2, 3948, 3949, 9, 9, 2, 2, 3949, 3950, 9, 5, 2, 2, 3950, 3951, 9, 5, 2, 2, 3951, 3952, 9, 10, 2, 2, 3952, 3953, 9, 13, 2, 2, 3953, 3954, 9, 6, 2, 2, 3954, 3955, 5, 1152, 576, 2, 3955, 3956, 9, 7, 2, 2, 3956, 3957, 9, 11, 2, 2, 3957, 3958, 9, 20, 2, 2, 3958, 3959, 9, 10, 2, 2, 3959, 3960, 9, 15, 2, 2, 3960, 3961, 9, 2, 2, 2, 3961, 699, 3, 2, 2, 2, 3962, 3963, 9, 16, 2, 2, 3963, 3964, 9, 5, 2, 2, 3964, 3965, 9, 10, 2, 2, 3965, 3966, 9, 10, 2, 2, 3966, 3967, 9, 25, 2, 2, 3967, 3968, 9, 10, 2, 2, 3968, 701, 3, 2, 2, 2, 3969, 3970, 9, 16, 2, 2, 3970, 3971, 9, 9, 2, 2, 3971, 3972, 9, 8, 2, 2, 3972, 3973, 9, 8, 2, 2, 3973, 703, 3, 2, 2, 2, 3974, 3975, 9, 12, 2, 2, 3975, 3976, 9, 8, 2, 2, 3976, 3977, 9, 12, 2, 2, 3977, 3978, 9, 21, 2, 2, 3978, 3979, 9, 10, 2, 2, 3979, 705, 3, 2, 2, 2, 3980, 3981, 9, 12, 2, 2, 3981, 3982, 9, 13, 2, 2, 3982, 3983, 9, 13, 2, 2, 3983, 3984, 9, 10, 2, 2, 3984, 3985, 9, 5, 2, 2, 3985, 707, 3, 2, 2, 2, 3986, 3987, 9, 12, 2, 2, 3987, 3988, 9, 7, 2, 2, 3988, 709, 3, 2, 2, 2, 3989, 3990, 9, 12, 2, 2, 3990, 3991, 9, 7, 2, 2, 3991, 3992, 9, 13, 2, 2, 3992, 3993, 9, 9, 2, 2, 3993, 3994, 9, 8, 2, 2, 3994, 3995, 9, 8, 2, 2, 3995, 711, 3, 2, 2, 2, 3996, 3997, 9, 26, 2, 2, 3997, 3998, 9, 4, 2, 2, 3998, 3999, 9, 12, 2, 2, 3999, 4000, 9, 13, 2, 2, 4000, 713, 3, 2, 2, 2, 4001, 4002, 9, 8, 2, 2, 4002, 4003, 9, 10, 2, 2, 4003, 4004, 9, 16, 2, 2, 4004, 4005, 9, 6, 2, 2, 4005, 715, 3, 2, 2, 2, 4006, 4007, 9, 8, 2, 2, 4007, 4008, 9, 12, 2, 2, 4008, 4009, 9, 21, 2, 2, 4009, 4010, 9, 10, 2, 2, 4010, 717, 3, 2, 2, 2, 4011, 4012, 9, 13, 2, 2, 4012, 4013, 9, 2, 2, 2, 4013, 4014, 9, 6, 2, 2, 4014, 4015, 9, 9, 2, 2, 4015, 4016, 9, 5, 2, 2, 4016, 4017, 9, 2, 2, 2, 4017, 4018, 9, 8, 2, 2, 4018, 719, 3, 2, 2, 2, 4019, 4020, 9, 13, 2, 2, 4020, 4021, 9, 4, 2, 2, 4021, 4022, 9, 6, 2, 2, 4022, 4023, 9, 13, 2, 2, 4023, 4024, 9, 9, 2, 2, 4024, 4025, 9, 8, 2, 2, 4025, 4026, 9, 8, 2, 2, 4026, 721, 3, 2, 2, 2, 4027, 4028, 9, 4, 2, 2, 4028, 4029, 9, 9, 2, 2, 4029, 4030, 9, 6, 2, 2, 4030, 4031, 9, 10, 2, 2, 4031, 4032, 9, 5, 2, 2, 4032, 723, 3, 2, 2, 2, 4033, 4034, 9, 4, 2, 2, 4034, 4035, 9, 23, 2, 2, 4035, 4036, 9, 10, 2, 2, 4036, 4037, 9, 5, 2, 2, 4037, 4038, 9, 8, 2, 2, 4038, 4039, 9, 2, 2, 2, 4039, 4040, 9, 22, 2, 2, 4040, 4041, 9, 7, 2, 2, 4041, 725, 3, 2, 2, 2, 4042, 4043, 9, 5, 2, 2, 4043, 4044, 9, 12, 2, 2, 4044, 4045, 9, 17, 2, 2, 4045, 4046, 9, 20, 2, 2, 4046, 4047, 9, 6, 2, 2, 4047, 727, 3, 2, 2, 2, 4048, 4049, 9, 7, 2, 2, 4049, 4050, 9, 12, 2, 2, 4050, 4051, 9, 15, 2, 2, 4051, 4052, 9, 12, 2, 2, 4052, 4053, 9, 8, 2, 2, 4053, 4054, 9, 2, 2, 2, 4054, 4055, 9, 5, 2, 2, 4055, 729, 3, 2, 2, 2, 4056, 4057, 9, 6, 2, 2, 4057, 4058, 9, 2, 2, 2, 4058, 4059, 9, 3, 2, 2, 4059, 4060, 9, 8, 2, 2, 4060, 4061, 9, 10, 2, 2, 4061, 4062, 9, 7, 2, 2, 4062, 4063, 9, 2, 2, 2, 4063, 4064, 9, 15, 2, 2, 4064, 4065, 9, 22, 2, 2, 4065, 4066, 9, 8, 2, 2, 4066, 4067, 9, 10, 2, 2, 4067, 731, 3, 2, 2, 2, 4068, 4069, 9, 23, 2, 2, 4069, 4070, 9, 10, 2, 2, 4070, 4071, 9, 5, 2, 2, 4071, 4072, 9, 3, 2, 2, 4072, 4073, 9, 4, 2, 2, 4073, 4074, 9, 7, 2, 2, 4074, 4075, 9, 10, 2, 2, 4075, 733, 3, 2, 2, 2, 4076, 4077, 9, 2, 2, 2, 4077, 4078, 9, 8, 2, 2, 4078, 4079, 9, 8, 2, 2, 4079, 735, 3, 2, 2, 2, 4080, 4081, 9, 2, 2, 2, 4081, 4082, 9, 13, 2, 2, 4082, 4083, 9, 2, 2, 2, 4083, 4084, 9, 8, 2, 2, 4084, 4085, 9, 19, 2, 2, 4085, 4086, 9, 7, 2, 2, 4086, 4087, 9, 10, 2, 2, 4087, 737, 3, 2, 2, 2, 4088, 4089, 9, 2, 2, 2, 4089, 4090, 9, 13, 2, 2, 4090, 4091, 9, 2, 2, 2, 4091, 4092, 9, 8, 2, 2, 4092, 4093, 9, 19, 2, 2, 4093, 4094, 9, 25, 2, 2, 4094, 4095, 9, 10, 2, 2, 4095, 739, 3, 2, 2, 2, 4096, 4097, 9, 2, 2, 2, 4097, 4098, 9, 13, 2, 2, 4098, 4099, 9, 14, 2, 2, 4099, 741, 3, 2, 2, 2, 4100, 4101, 9, 2, 2, 2, 4101, 4102, 9, 13, 2, 2, 4102, 4103, 9, 19, 2, 2, 4103, 743, 3, 2, 2, 2, 4104, 4105, 9, 2, 2, 2, 4105, 4106, 9, 5, 2, 2, 4106, 4107, 9, 5, 2, 2, 4107, 4108, 9, 2, 2, 2, 4108, 4109, 9, 19, 2, 2, 4109, 745, 3, 2, 2, 2, 4110, 4111, 9, 2, 2, 2, 4111, 4112, 9, 7, 2, 2, 4112, 747, 3, 2, 2, 2, 4113, 4114, 9, 2, 2, 2, 4114, 4115, 9, 7, 2, 2, 4115, 4116, 9, 11, 2, 2, 4116, 749, 3, 2, 2, 2, 4117, 4118, 9, 2, 2, 2, 4118, 4119, 9, 7, 2, 2, 4119, 4120, 9, 19, 2, 2, 4120, 4121, 9, 15, 2, 2, 4121, 4122, 9, 15, 2, 2, 4122, 4123, 9, 10, 2, 2, 4123, 4124, 9, 6, 2, 2, 4124, 4125, 9, 5, 2, 2, 4125, 4126, 9, 12, 2, 2, 4126, 4127, 9, 11, 2, 2, 4127, 751, 3, 2, 2, 2, 4128, 4129, 9, 3, 2, 2, 4129, 4130, 9, 4, 2, 2, 4130, 4131, 9, 6, 2, 2, 4131, 4132, 9, 20, 2, 2, 4132, 753, 3, 2, 2, 2, 4133, 4134, 9, 11, 2, 2, 4134, 4135, 9, 2, 2, 2, 4135, 4136, 9, 7, 2, 2, 4136, 4137, 9, 10, 2, 2, 4137, 755, 3, 2, 2, 2, 4138, 4139, 9, 11, 2, 2, 4139, 4140, 9, 2, 2, 2, 4140, 4141, 9, 7, 2, 2, 4141, 4142, 9, 6, 2, 2, 4142, 757, 3, 2, 2, 2, 4143, 4144, 9, 11, 2, 2, 4144, 4145, 9, 20, 2, 2, 4145, 4146, 9, 10, 2, 2, 4146, 4147, 9, 11, 2, 2, 4147, 4148, 9, 21, 2, 2, 4148, 759, 3, 2, 2, 2, 4149, 4150, 9, 11, 2, 2, 4150, 4151, 9, 4, 2, 2, 4151, 4152, 9, 8, 2, 2, 4152, 4153, 9, 8, 2, 2, 4153, 4154, 9, 2, 2, 2, 4154, 4155, 9, 6, 2, 2, 4155, 4156, 9, 10, 2, 2, 4156, 761, 3, 2, 2, 2, 4157, 4158, 9, 11, 2, 2, 4158, 4159, 9, 4, 2, 2, 4159, 4160, 9, 8, 2, 2, 4160, 4161, 9, 9, 2, 2, 4161, 4162, 9, 15, 2, 2, 4162, 4163, 9, 13, 2, 2, 4163, 763, 3, 2, 2, 2, 4164, 4165, 9, 11, 2, 2, 4165, 4166, 9, 4, 2, 2, 4166, 4167, 9, 13, 2, 2, 4167, 4168, 9, 7, 2, 2, 4168, 4169, 9, 6, 2, 2, 4169, 4170, 9, 5, 2, 2, 4170, 4171, 9, 2, 2, 2, 4171, 4172, 9, 12, 2, 2, 4172, 4173, 9, 13, 2, 2, 4173, 4174, 9, 6, 2, 2, 4174, 765, 3, 2, 2, 2, 4175, 4176, 9, 11, 2, 2, 4176, 4177, 9, 5, 2, 2, 4177, 4178, 9, 10, 2, 2, 4178, 4179, 9, 2, 2, 2, 4179, 4180, 9, 6, 2, 2, 4180, 4181, 9, 10, 2, 2, 4181, 767, 3, 2, 2, 2, 4182, 4183, 9, 11, 2, 2, 4183, 4184, 9, 9, 2, 2, 4184, 4185, 9, 5, 2, 2, 4185, 4186, 9, 5, 2, 2, 4186, 4187, 9, 10, 2, 2, 4187, 4188, 9, 13, 2, 2, 4188, 4189, 9, 6, 2, 2, 4189, 4190, 5, 1152, 576, 2, 4190, 4191, 9, 11, 2, 2, 4191, 4192, 9, 2, 2, 2, 4192, 4193, 9, 6, 2, 2, 4193, 4194, 9, 2, 2, 2, 4194, 4195, 9, 8, 2, 2, 4195, 4196, 9, 4, 2, 2, 4196, 4197, 9, 17, 2, 2, 4197, 769, 3, 2, 2, 2, 4198, 4199, 9, 11, 2, 2, 4199, 4200, 9, 9, 2, 2, 4200, 4201, 9, 5, 2, 2, 4201, 4202, 9, 5, 2, 2, 4202, 4203, 9, 10, 2, 2, 4203, 4204, 9, 13, 2, 2, 4204, 4205, 9, 6, 2, 2, 4205, 4206, 5, 1152, 576, 2, 4206, 4207, 9, 14, 2, 2, 4207, 4208, 9, 2, 2, 2, 4208, 4209, 9, 6, 2, 2, 4209, 4210, 9, 10, 2, 2, 4210, 771, 3, 2, 2, 2, 4211, 4212, 9, 11, 2, 2, 4212, 4213, 9, 9, 2, 2, 4213, 4214, 9, 5, 2, 2, 4214, 4215, 9, 5, 2, 2, 4215, 4216, 9, 10, 2, 2, 4216, 4217, 9, 13, 2, 2, 4217, 4218, 9, 6, 2, 2, 4218, 4219, 5, 1152, 576, 2, 4219, 4220, 9, 5, 2, 2, 4220, 4221, 9, 4, 2, 2, 4221, 4222, 9, 8, 2, 2, 4222, 4223, 9, 10, 2, 2, 4223, 773, 3, 2, 2, 2, 4224, 4225, 9, 11, 2, 2, 4225, 4226, 9, 9, 2, 2, 4226, 4227, 9, 5, 2, 2, 4227, 4228, 9, 5, 2, 2, 4228, 4229, 9, 10, 2, 2, 4229, 4230, 9, 13, 2, 2, 4230, 4231, 9, 6, 2, 2, 4231, 4232, 5, 1152, 576, 2, 4232, 4233, 9, 6, 2, 2, 4233, 4234, 9, 12, 2, 2, 4234, 4235, 9, 15, 2, 2, 4235, 4236, 9, 10, 2, 2, 4236, 775, 3, 2, 2, 2, 4237, 4238, 9, 11, 2, 2, 4238, 4239, 9, 9, 2, 2, 4239, 4240, 9, 5, 2, 2, 4240, 4241, 9, 5, 2, 2, 4241, 4242, 9, 10, 2, 2, 4242, 4243, 9, 13, 2, 2, 4243, 4244, 9, 6, 2, 2, 4244, 4245, 5, 1152, 576, 2, 4245, 4246, 9, 6, 2, 2, 4246, 4247, 9, 12, 2, 2, 4247, 4248, 9, 15, 2, 2, 4248, 4249, 9, 10, 2, 2, 4249, 4250, 9, 7, 2, 2, 4250, 4251, 9, 6, 2, 2, 4251, 4252, 9, 2, 2, 2, 4252, 4253, 9, 15, 2, 2, 4253, 4254, 9, 22, 2, 2, 4254, 777, 3, 2, 2, 2, 4255, 4256, 9, 11, 2, 2, 4256, 4257, 9, 9, 2, 2, 4257, 4258, 9, 5, 2, 2, 4258, 4259, 9, 5, 2, 2, 4259, 4260, 9, 10, 2, 2, 4260, 4261, 9, 13, 2, 2, 4261, 4262, 9, 6, 2, 2, 4262, 4263, 5, 1152, 576, 2, 4263, 4264, 9, 9, 2, 2, 4264, 4265, 9, 7, 2, 2, 4265, 4266, 9, 10, 2, 2, 4266, 4267, 9, 5, 2, 2, 4267, 779, 3, 2, 2, 2, 4268, 4269, 9, 14, 2, 2, 4269, 4270, 9, 10, 2, 2, 4270, 4271, 9, 16, 2, 2, 4271, 4272, 9, 2, 2, 2, 4272, 4273, 9, 9, 2, 2, 4273, 4274, 9, 8, 2, 2, 4274, 4275, 9, 6, 2, 2, 4275, 781, 3, 2, 2, 2, 4276, 4277, 9, 14, 2, 2, 4277, 4278, 9, 10, 2, 2, 4278, 4279, 9, 16, 2, 2, 4279, 4280, 9, 10, 2, 2, 4280, 4281, 9, 5, 2, 2, 4281, 4282, 9, 5, 2, 2, 4282, 4283, 9, 2, 2, 2, 4283, 4284, 9, 3, 2, 2, 4284, 4285, 9, 8, 2, 2, 4285, 4286, 9, 10, 2, 2, 4286, 783, 3, 2, 2, 2, 4287, 4288, 9, 14, 2, 2, 4288, 4289, 9, 10, 2, 2, 4289, 4290, 9, 7, 2, 2, 4290, 4291, 9, 11, 2, 2, 4291, 785, 3, 2, 2, 2, 4292, 4293, 9, 14, 2, 2, 4293, 4294, 9, 12, 2, 2, 4294, 4295, 9, 7, 2, 2, 4295, 4296, 9, 6, 2, 2, 4296, 4297, 9, 12, 2, 2, 4297, 4298, 9, 13, 2, 2, 4298, 4299, 9, 11, 2, 2, 4299, 4300, 9, 6, 2, 2, 4300, 787, 3, 2, 2, 2, 4301, 4302, 9, 14, 2, 2, 4302, 4303, 9, 4, 2, 2, 4303, 789, 3, 2, 2, 2, 4304, 4305, 9, 10, 2, 2, 4305, 4306, 9, 8, 2, 2, 4306, 4307, 9, 7, 2, 2, 4307, 4308, 9, 10, 2, 2, 4308, 791, 3, 2, 2, 2, 4309, 4310, 9, 10, 2, 2, 4310, 4311, 9, 13, 2, 2, 4311, 4312, 9, 14, 2, 2, 4312, 793, 3, 2, 2, 2, 4313, 4314, 9, 10, 2, 2, 4314, 4315, 9, 24, 2, 2, 4315, 4316, 9, 11, 2, 2, 4316, 4317, 9, 10, 2, 2, 4317, 4318, 9, 22, 2, 2, 4318, 4319, 9, 6, 2, 2, 4319, 795, 3, 2, 2, 2, 4320, 4321, 9, 16, 2, 2, 4321, 4322, 9, 2, 2, 2, 4322, 4323, 9, 8, 2, 2, 4323, 4324, 9, 7, 2, 2, 4324, 4325, 9, 10, 2, 2, 4325, 797, 3, 2, 2, 2, 4326, 4327, 9, 16, 2, 2, 4327, 4328, 9, 10, 2, 2, 4328, 4329, 9, 6, 2, 2, 4329, 4330, 9, 11, 2, 2, 4330, 4331, 9, 20, 2, 2, 4331, 799, 3, 2, 2, 2, 4332, 4333, 9, 16, 2, 2, 4333, 4334, 9, 4, 2, 2, 4334, 4335, 9, 5, 2, 2, 4335, 801, 3, 2, 2, 2, 4336, 4337, 9, 16, 2, 2, 4337, 4338, 9, 4, 2, 2, 4338, 4339, 9, 5, 2, 2, 4339, 4340, 9, 10, 2, 2, 4340, 4341, 9, 12, 2, 2, 4341, 4342, 9, 17, 2, 2, 4342, 4343, 9, 13, 2, 2, 4343, 803, 3, 2, 2, 2, 4344, 4345, 9, 16, 2, 2, 4345, 4346, 9, 5, 2, 2, 4346, 4347, 9, 4, 2, 2, 4347, 4348, 9, 15, 2, 2, 4348, 805, 3, 2, 2, 2, 4349, 4350, 9, 17, 2, 2, 4350, 4351, 9, 5, 2, 2, 4351, 4352, 9, 2, 2, 2, 4352, 4353, 9, 13, 2, 2, 4353, 4354, 9, 6, 2, 2, 4354, 807, 3, 2, 2, 2, 4355, 4356, 9, 17, 2, 2, 4356, 4357, 9, 5, 2, 2, 4357, 4358, 9, 4, 2, 2, 4358, 4359, 9, 9, 2, 2, 4359, 4360, 9, 22, 2, 2, 4360, 809, 3, 2, 2, 2, 4361, 4362, 9, 20, 2, 2, 4362, 4363, 9, 2, 2, 2, 4363, 4364, 9, 23, 2, 2, 4364, 4365, 9, 12, 2, 2, 4365, 4366, 9, 13, 2, 2, 4366, 4367, 9, 17, 2, 2, 4367, 811, 3, 2, 2, 2, 4368, 4369, 9, 12, 2, 2, 4369, 4370, 9, 13, 2, 2, 4370, 813, 3, 2, 2, 2, 4371, 4372, 9, 12, 2, 2, 4372, 4373, 9, 13, 2, 2, 4373, 4374, 9, 12, 2, 2, 4374, 4375, 9, 6, 2, 2, 4375, 4376, 9, 12, 2, 2, 4376, 4377, 9, 2, 2, 2, 4377, 4378, 9, 8, 2, 2, 4378, 4379, 9, 8, 2, 2, 4379, 4380, 9, 19, 2, 2, 4380, 815, 3, 2, 2, 2, 4381, 4382, 9, 12, 2, 2, 4382, 4383, 9, 13, 2, 2, 4383, 4384, 9, 6, 2, 2, 4384, 4385, 9, 10, 2, 2, 4385, 4386, 9, 5, 2, 2, 4386, 4387, 9, 7, 2, 2, 4387, 4388, 9, 10, 2, 2, 4388, 4389, 9, 11, 2, 2, 4389, 4390, 9, 6, 2, 2, 4390, 817, 3, 2, 2, 2, 4391, 4392, 9, 12, 2, 2, 4392, 4393, 9, 13, 2, 2, 4393, 4394, 9, 6, 2, 2, 4394, 4395, 9, 4, 2, 2, 4395, 819, 3, 2, 2, 2, 4396, 4397, 9, 8, 2, 2, 4397, 4398, 9, 2, 2, 2, 4398, 4399, 9, 6, 2, 2, 4399, 4400, 9, 10, 2, 2, 4400, 4401, 9, 5, 2, 2, 4401, 4402, 9, 2, 2, 2, 4402, 4403, 9, 8, 2, 2, 4403, 821, 3, 2, 2, 2, 4404, 4405, 9, 8, 2, 2, 4405, 4406, 9, 10, 2, 2, 4406, 4407, 9, 2, 2, 2, 4407, 4408, 9, 14, 2, 2, 4408, 4409, 9, 12, 2, 2, 4409, 4410, 9, 13, 2, 2, 4410, 4411, 9, 17, 2, 2, 4411, 823, 3, 2, 2, 2, 4412, 4413, 9, 8, 2, 2, 4413, 4414, 9, 12, 2, 2, 4414, 4415, 9, 15, 2, 2, 4415, 4416, 9, 12, 2, 2, 4416, 4417, 9, 6, 2, 2, 4417, 825, 3, 2, 2, 2, 4418, 4419, 9, 8, 2, 2, 4419, 4420, 9, 4, 2, 2, 4420, 4421, 9, 11, 2, 2, 4421, 4422, 9, 2, 2, 2, 4422, 4423, 9, 8, 2, 2, 4423, 4424, 9, 6, 2, 2, 4424, 4425, 9, 12, 2, 2, 4425, 4426, 9, 15, 2, 2, 4426, 4427, 9, 10, 2, 2, 4427, 827, 3, 2, 2, 2, 4428, 4429, 9, 8, 2, 2, 4429, 4430, 9, 4, 2, 2, 4430, 4431, 9, 11, 2, 2, 4431, 4432, 9, 2, 2, 2, 4432, 4433, 9, 8, 2, 2, 4433, 4434, 9, 6, 2, 2, 4434, 4435, 9, 12, 2, 2, 4435, 4436, 9, 15, 2, 2, 4436, 4437, 9, 10, 2, 2, 4437, 4438, 9, 7, 2, 2, 4438, 4439, 9, 6, 2, 2, 4439, 4440, 9, 2, 2, 2, 4440, 4441, 9, 15, 2, 2, 4441, 4442, 9, 22, 2, 2, 4442, 829, 3, 2, 2, 2, 4443, 4444, 9, 13, 2, 2, 4444, 4445, 9, 4, 2, 2, 4445, 4446, 9, 6, 2, 2, 4446, 831, 3, 2, 2, 2, 4447, 4448, 9, 13, 2, 2, 4448, 4449, 9, 9, 2, 2, 4449, 4450, 9, 8, 2, 2, 4450, 4451, 9, 8, 2, 2, 4451, 833, 3, 2, 2, 2, 4452, 4453, 9, 4, 2, 2, 4453, 4454, 9, 16, 2, 2, 4454, 4455, 9, 16, 2, 2, 4455, 4456, 9, 7, 2, 2, 4456, 4457, 9, 10, 2, 2, 4457, 4458, 9, 6, 2, 2, 4458, 835, 3, 2, 2, 2, 4459, 4460, 9, 4, 2, 2, 4460, 4461, 9, 13, 2, 2, 4461, 837, 3, 2, 2, 2, 4462, 4463, 9, 4, 2, 2, 4463, 4464, 9, 13, 2, 2, 4464, 4465, 9, 8, 2, 2, 4465, 4466, 9, 19, 2, 2, 4466, 839, 3, 2, 2, 2, 4467, 4468, 9, 4, 2, 2, 4468, 4469, 9, 5, 2, 2, 4469, 841, 3, 2, 2, 2, 4470, 4471, 9, 4, 2, 2, 4471, 4472, 9, 5, 2, 2, 4472, 4473, 9, 14, 2, 2, 4473, 4474, 9, 10, 2, 2, 4474, 4475, 9, 5, 2, 2, 4475, 843, 3, 2, 2, 2, 4476, 4477, 9, 22, 2, 2, 4477, 4478, 9, 8, 2, 2, 4478, 4479, 9, 2, 2, 2, 4479, 4480, 9, 11, 2, 2, 4480, 4481, 9, 12, 2, 2, 4481, 4482, 9, 13, 2, 2, 4482, 4483, 9, 17, 2, 2, 4483, 845, 3, 2, 2, 2, 4484, 4485, 9, 22, 2, 2, 4485, 4486, 9, 5, 2, 2, 4486, 4487, 9, 12, 2, 2, 4487, 4488, 9, 15, 2, 2, 4488, 4489, 9, 2, 2, 2, 4489, 4490, 9, 5, 2, 2, 4490, 4491, 9, 19, 2, 2, 4491, 847, 3, 2, 2, 2, 4492, 4493, 9, 5, 2, 2, 4493, 4494, 9, 10, 2, 2, 4494, 4495, 9, 16, 2, 2, 4495, 4496, 9, 10, 2, 2, 4496, 4497, 9, 5, 2, 2, 4497, 4498, 9, 10, 2, 2, 4498, 4499, 9, 13, 2, 2, 4499, 4500, 9, 11, 2, 2, 4500, 4501, 9, 10, 2, 2, 4501, 4502, 9, 7, 2, 2, 4502, 849, 3, 2, 2, 2, 4503, 4504, 9, 5, 2, 2, 4504, 4505, 9, 10, 2, 2, 4505, 4506, 9, 6, 2, 2, 4506, 4507, 9, 9, 2, 2, 4507, 4508, 9, 5, 2, 2, 4508, 4509, 9, 13, 2, 2, 4509, 4510, 9, 12, 2, 2, 4510, 4511, 9, 13, 2, 2, 4511, 4512, 9, 17, 2, 2, 4512, 851, 3, 2, 2, 2, 4513, 4514, 9, 7, 2, 2, 4514, 4515, 9, 10, 2, 2, 4515, 4516, 9, 8, 2, 2, 4516, 4517, 9, 10, 2, 2, 4517, 4518, 9, 11, 2, 2, 4518, 4519, 9, 6, 2, 2, 4519, 853, 3, 2, 2, 2, 4520, 4521, 9, 7, 2, 2, 4521, 4522, 9, 10, 2, 2, 4522, 4523, 9, 7, 2, 2, 4523, 4524, 9, 7, 2, 2, 4524, 4525, 9, 12, 2, 2, 4525, 4526, 9, 4, 2, 2, 4526, 4527, 9, 13, 2, 2, 4527, 4528, 5, 1152, 576, 2, 4528, 4529, 9, 9, 2, 2, 4529, 4530, 9, 7, 2, 2, 4530, 4531, 9, 10, 2, 2, 4531, 4532, 9, 5, 2, 2, 4532, 855, 3, 2, 2, 2, 4533, 4534, 9, 7, 2, 2, 4534, 4535, 9, 4, 2, 2, 4535, 4536, 9, 15, 2, 2, 4536, 4537, 9, 10, 2, 2, 4537, 857, 3, 2, 2, 2, 4538, 4539, 9, 7, 2, 2, 4539, 4540, 9, 19, 2, 2, 4540, 4541, 9, 15, 2, 2, 4541, 4542, 9, 15, 2, 2, 4542, 4543, 9, 10, 2, 2, 4543, 4544, 9, 6, 2, 2, 4544, 4545, 9, 5, 2, 2, 4545, 4546, 9, 12, 2, 2, 4546, 4547, 9, 11, 2, 2, 4547, 859, 3, 2, 2, 2, 4548, 4549, 9, 6, 2, 2, 4549, 4550, 9, 2, 2, 2, 4550, 4551, 9, 3, 2, 2, 4551, 4552, 9, 8, 2, 2, 4552, 4553, 9, 10, 2, 2, 4553, 861, 3, 2, 2, 2, 4554, 4555, 9, 6, 2, 2, 4555, 4556, 9, 20, 2, 2, 4556, 4557, 9, 10, 2, 2, 4557, 4558, 9, 13, 2, 2, 4558, 863, 3, 2, 2, 2, 4559, 4560, 9, 6, 2, 2, 4560, 4561, 9, 4, 2, 2, 4561, 865, 3, 2, 2, 2, 4562, 4563, 9, 6, 2, 2, 4563, 4564, 9, 5, 2, 2, 4564, 4565, 9, 2, 2, 2, 4565, 4566, 9, 12, 2, 2, 4566, 4567, 9, 8, 2, 2, 4567, 4568, 9, 12, 2, 2, 4568, 4569, 9, 13, 2, 2, 4569, 4570, 9, 17, 2, 2, 4570, 867, 3, 2, 2, 2, 4571, 4572, 9, 6, 2, 2, 4572, 4573, 9, 5, 2, 2, 4573, 4574, 9, 9, 2, 2, 4574, 4575, 9, 10, 2, 2, 4575, 869, 3, 2, 2, 2, 4576, 4577, 9, 9, 2, 2, 4577, 4578, 9, 13, 2, 2, 4578, 4579, 9, 12, 2, 2, 4579, 4580, 9, 4, 2, 2, 4580, 4581, 9, 13, 2, 2, 4581, 871, 3, 2, 2, 2, 4582, 4583, 9, 9, 2, 2, 4583, 4584, 9, 13, 2, 2, 4584, 4585, 9, 12, 2, 2, 4585, 4586, 9, 27, 2, 2, 4586, 4587, 9, 9, 2, 2, 4587, 4588, 9, 10, 2, 2, 4588, 873, 3, 2, 2, 2, 4589, 4590, 9, 9, 2, 2, 4590, 4591, 9, 7, 2, 2, 4591, 4592, 9, 10, 2, 2, 4592, 4593, 9, 5, 2, 2, 4593, 875, 3, 2, 2, 2, 4594, 4595, 9, 9, 2, 2, 4595, 4596, 9, 7, 2, 2, 4596, 4597, 9, 12, 2, 2, 4597, 4598, 9, 13, 2, 2, 4598, 4599, 9, 17, 2, 2, 4599, 877, 3, 2, 2, 2, 4600, 4601, 9, 23, 2, 2, 4601, 4602, 9, 2, 2, 2, 4602, 4603, 9, 5, 2, 2, 4603, 4604, 9, 12, 2, 2, 4604, 4605, 9, 2, 2, 2, 4605, 4606, 9, 14, 2, 2, 4606, 4607, 9, 12, 2, 2, 4607, 4608, 9, 11, 2, 2, 4608, 879, 3, 2, 2, 2, 4609, 4610, 9, 18, 2, 2, 4610, 4611, 9, 20, 2, 2, 4611, 4612, 9, 10, 2, 2, 4612, 4613, 9, 13, 2, 2, 4613, 881, 3, 2, 2, 2, 4614, 4615, 9, 18, 2, 2, 4615, 4616, 9, 20, 2, 2, 4616, 4617, 9, 10, 2, 2, 4617, 4618, 9, 5, 2, 2, 4618, 4619, 9, 10, 2, 2, 4619, 883, 3, 2, 2, 2, 4620, 4621, 9, 18, 2, 2, 4621, 4622, 9, 12, 2, 2, 4622, 4623, 9, 13, 2, 2, 4623, 4624, 9, 14, 2, 2, 4624, 4625, 9, 4, 2, 2, 4625, 4626, 9, 18, 2, 2, 4626, 885, 3, 2, 2, 2, 4627, 4628, 9, 18, 2, 2, 4628, 4629, 9, 12, 2, 2, 4629, 4630, 9, 6, 2, 2, 4630, 4631, 9, 20, 2, 2, 4631, 887, 3, 2, 2, 2, 4632, 4633, 9, 2, 2, 2, 4633, 4634, 9, 8, 2, 2, 4634, 4635, 9, 12, 2, 2, 4635, 4636, 9, 17, 2, 2, 4636, 4637, 9, 13, 2, 2, 4637, 4638, 9, 15, 2, 2, 4638, 4639, 9, 10, 2, 2, 4639, 4640, 9, 13, 2, 2, 4640, 4641, 9, 6, 2, 2, 4641, 889, 3, 2, 2, 2, 4642, 4643, 9, 3, 2, 2, 4643, 4644, 9, 2, 2, 2, 4644, 4645, 9, 7, 2, 2, 4645, 4646, 9, 10, 2, 2, 4646, 4647, 9, 6, 2, 2, 4647, 4648, 9, 19, 2, 2, 4648, 4649, 9, 22, 2, 2, 4649, 4650, 9, 10, 2, 2, 4650, 891, 3, 2, 2, 2, 4651, 4652, 9, 3, 2, 2, 4652, 4653, 9, 9, 2, 2, 4653, 4654, 9, 16, 2, 2, 4654, 4655, 9, 16, 2, 2, 4655, 4656, 9, 10, 2, 2, 4656, 4657, 9, 5, 2, 2, 4657, 4658, 9, 7, 2, 2, 4658, 893, 3, 2, 2, 2, 4659, 4660, 9, 3, 2, 2, 4660, 4661, 9, 19, 2, 2, 4661, 4662, 9, 22, 2, 2, 4662, 4663, 9, 2, 2, 2, 4663, 4664, 9, 7, 2, 2, 4664, 4665, 9, 7, 2, 2, 4665, 4666, 9, 5, 2, 2, 4666, 4667, 9, 8, 2, 2, 4667, 4668, 9, 7, 2, 2, 4668, 895, 3, 2, 2, 2, 4669, 4670, 9, 11, 2, 2, 4670, 4671, 9, 2, 2, 2, 4671, 4672, 9, 13, 2, 2, 4672, 4673, 9, 4, 2, 2, 4673, 4674, 9, 13, 2, 2, 4674, 4675, 9, 12, 2, 2, 4675, 4676, 9, 11, 2, 2, 4676, 4677, 9, 2, 2, 2, 4677, 4678, 9, 8, 2, 2, 4678, 897, 3, 2, 2, 2, 4679, 4680, 9, 11, 2, 2, 4680, 4681, 9, 2, 2, 2, 4681, 4682, 9, 6, 2, 2, 4682, 4683, 9, 10, 2, 2, 4683, 4684, 9, 17, 2, 2, 4684, 4685, 9, 4, 2, 2, 4685, 4686, 9, 5, 2, 2, 4686, 4687, 9, 19, 2, 2, 4687, 899, 3, 2, 2, 2, 4688, 4689, 9, 11, 2, 2, 4689, 4690, 9, 4, 2, 2, 4690, 4691, 9, 8, 2, 2, 4691, 4692, 9, 8, 2, 2, 4692, 4693, 9, 2, 2, 2, 4693, 4694, 9, 6, 2, 2, 4694, 4695, 9, 2, 2, 2, 4695, 4696, 9, 3, 2, 2, 4696, 4697, 9, 8, 2, 2, 4697, 4698, 9, 10, 2, 2, 4698, 901, 3, 2, 2, 2, 4699, 4700, 9, 11, 2, 2, 4700, 4701, 9, 4, 2, 2, 4701, 4702, 9, 15, 2, 2, 4702, 4703, 9, 3, 2, 2, 4703, 4704, 9, 12, 2, 2, 4704, 4705, 9, 13, 2, 2, 4705, 4706, 9, 10, 2, 2, 4706, 4707, 9, 16, 2, 2, 4707, 4708, 9, 9, 2, 2, 4708, 4709, 9, 13, 2, 2, 4709, 4710, 9, 11, 2, 2, 4710, 903, 3, 2, 2, 2, 4711, 4712, 9, 11, 2, 2, 4712, 4713, 9, 4, 2, 2, 4713, 4714, 9, 15, 2, 2, 4714, 4715, 9, 15, 2, 2, 4715, 4716, 9, 9, 2, 2, 4716, 4717, 9, 6, 2, 2, 4717, 4718, 9, 2, 2, 2, 4718, 4719, 9, 6, 2, 2, 4719, 4720, 9, 4, 2, 2, 4720, 4721, 9, 5, 2, 2, 4721, 905, 3, 2, 2, 2, 4722, 4723, 9, 11, 2, 2, 4723, 4724, 9, 4, 2, 2, 4724, 4725, 9, 13, 2, 2, 4725, 4726, 9, 13, 2, 2, 4726, 4727, 9, 10, 2, 2, 4727, 4728, 9, 11, 2, 2, 4728, 4729, 9, 6, 2, 2, 4729, 907, 3, 2, 2, 2, 4730, 4731, 9, 11, 2, 2, 4731, 4732, 9, 4, 2, 2, 4732, 4733, 9, 7, 2, 2, 4733, 4734, 9, 6, 2, 2, 4734, 4735, 9, 7, 2, 2, 4735, 909, 3, 2, 2, 2, 4736, 4737, 9, 11, 2, 2, 4737, 4738, 9, 5, 2, 2, 4738, 4739, 9, 10, 2, 2, 4739, 4740, 9, 2, 2, 2, 4740, 4741, 9, 6, 2, 2, 4741, 4742, 9, 10, 2, 2, 4742, 4743, 9, 14, 2, 2, 4743, 4744, 9, 3, 2, 2, 4744, 911, 3, 2, 2, 2, 4745, 4746, 9, 11, 2, 2, 4746, 4747, 9, 5, 2, 2, 4747, 4748, 9, 10, 2, 2, 4748, 4749, 9, 2, 2, 2, 4749, 4750, 9, 6, 2, 2, 4750, 4751, 9, 10, 2, 2, 4751, 4752, 9, 5, 2, 2, 4752, 4753, 9, 4, 2, 2, 4753, 4754, 9, 8, 2, 2, 4754, 4755, 9, 10, 2, 2, 4755, 913, 3, 2, 2, 2, 4756, 4757, 9, 14, 2, 2, 4757, 4758, 9, 10, 2, 2, 4758, 4759, 9, 7, 2, 2, 4759, 4760, 9, 10, 2, 2, 4760, 4761, 9, 5, 2, 2, 4761, 4762, 9, 12, 2, 2, 4762, 4763, 9, 2, 2, 2, 4763, 4764, 9, 8, 2, 2, 4764, 4765, 9, 16, 2, 2, 4765, 4766, 9, 9, 2, 2, 4766, 4767, 9, 13, 2, 2, 4767, 4768, 9, 11, 2, 2, 4768, 915, 3, 2, 2, 2, 4769, 4770, 9, 14, 2, 2, 4770, 4771, 9, 10, 2, 2, 4771, 4772, 9, 6, 2, 2, 4772, 4773, 9, 10, 2, 2, 4773, 4774, 9, 5, 2, 2, 4774, 4775, 9, 15, 2, 2, 4775, 4776, 9, 12, 2, 2, 4776, 4777, 9, 13, 2, 2, 4777, 4778, 9, 12, 2, 2, 4778, 4779, 9, 7, 2, 2, 4779, 4780, 9, 6, 2, 2, 4780, 4781, 9, 12, 2, 2, 4781, 4782, 9, 11, 2, 2, 4782, 917, 3, 2, 2, 2, 4783, 4784, 5, 134, 67, 2, 4784, 4785, 5, 1152, 576, 2, 4785, 4786, 9, 22, 2, 2, 4786, 4787, 9, 2, 2, 2, 4787, 4788, 9, 17, 2, 2, 4788, 4789, 9, 10, 2, 2, 4789, 4790, 5, 1152, 576, 2, 4790, 4791, 9, 7, 2, 2, 4791, 4792, 9, 21, 2, 2, 4792, 4793, 9, 12, 2, 2, 4793, 4794, 9, 22, 2, 2, 4794, 4795, 9, 22, 2, 2, 4795, 4796, 9, 12, 2, 2, 4796, 4797, 9, 13, 2, 2, 4797, 4798, 9, 17, 2, 2, 4798, 919, 3, 2, 2, 2, 4799, 4800, 9, 10, 2, 2, 4800, 4801, 9, 8, 2, 2, 4801, 4802, 9, 10, 2, 2, 4802, 4803, 9, 15, 2, 2, 4803, 4804, 9, 10, 2, 2, 4804, 4805, 9, 13, 2, 2, 4805, 4806, 9, 6, 2, 2, 4806, 921, 3, 2, 2, 2, 4807, 4808, 9, 10, 2, 2, 4808, 4809, 9, 24, 2, 2, 4809, 4810, 9, 6, 2, 2, 4810, 4811, 9, 10, 2, 2, 4811, 4812, 9, 13, 2, 2, 4812, 4813, 9, 14, 2, 2, 4813, 4814, 9, 10, 2, 2, 4814, 4815, 9, 14, 2, 2, 4815, 923, 3, 2, 2, 2, 4816, 4817, 9, 16, 2, 2, 4817, 4818, 9, 12, 2, 2, 4818, 4819, 9, 13, 2, 2, 4819, 4820, 9, 2, 2, 2, 4820, 4821, 9, 8, 2, 2, 4821, 4822, 9, 16, 2, 2, 4822, 4823, 9, 9, 2, 2, 4823, 4824, 9, 13, 2, 2, 4824, 4825, 9, 11, 2, 2, 4825, 925, 3, 2, 2, 2, 4826, 4827, 5, 924, 462, 2, 4827, 4828, 5, 1152, 576, 2, 4828, 4829, 9, 10, 2, 2, 4829, 4830, 9, 24, 2, 2, 4830, 4831, 9, 6, 2, 2, 4831, 4832, 9, 5, 2, 2, 4832, 4833, 9, 2, 2, 2, 4833, 927, 3, 2, 2, 2, 4834, 4835, 5, 924, 462, 2, 4835, 4836, 5, 1152, 576, 2, 4836, 4837, 9, 15, 2, 2, 4837, 4838, 9, 4, 2, 2, 4838, 4839, 9, 14, 2, 2, 4839, 4840, 9, 12, 2, 2, 4840, 4841, 9, 16, 2, 2, 4841, 4842, 9, 19, 2, 2, 4842, 929, 3, 2, 2, 2, 4843, 4844, 9, 16, 2, 2, 4844, 4845, 9, 4, 2, 2, 4845, 4846, 9, 5, 2, 2, 4846, 4847, 9, 11, 2, 2, 4847, 4848, 9, 10, 2, 2, 4848, 4849, 5, 1152, 576, 2, 4849, 4850, 9, 13, 2, 2, 4850, 4851, 9, 4, 2, 2, 4851, 4852, 9, 6, 2, 2, 4852, 4853, 5, 1152, 576, 2, 4853, 4854, 9, 13, 2, 2, 4854, 4855, 9, 9, 2, 2, 4855, 4856, 9, 8, 2, 2, 4856, 4857, 9, 8, 2, 2, 4857, 931, 3, 2, 2, 2, 4858, 4859, 9, 16, 2, 2, 4859, 4860, 9, 4, 2, 2, 4860, 4861, 9, 5, 2, 2, 4861, 4862, 9, 11, 2, 2, 4862, 4863, 9, 10, 2, 2, 4863, 4864, 5, 1152, 576, 2, 4864, 4865, 9, 13, 2, 2, 4865, 4866, 9, 9, 2, 2, 4866, 4867, 9, 8, 2, 2, 4867, 4868, 9, 8, 2, 2, 4868, 933, 3, 2, 2, 2, 4869, 4870, 9, 16, 2, 2, 4870, 4871, 9, 4, 2, 2, 4871, 4872, 9, 5, 2, 2, 4872, 4873, 9, 11, 2, 2, 4873, 4874, 9, 10, 2, 2, 4874, 4875, 5, 1152, 576, 2, 4875, 4876, 9, 27, 2, 2, 4876, 4877, 9, 9, 2, 2, 4877, 4878, 9, 4, 2, 2, 4878, 4879, 9, 6, 2, 2, 4879, 4880, 9, 10, 2, 2, 4880, 935, 3, 2, 2, 2, 4881, 4882, 9, 16, 2, 2, 4882, 4883, 9, 4, 2, 2, 4883, 4884, 9, 5, 2, 2, 4884, 4885, 9, 15, 2, 2, 4885, 4886, 9, 2, 2, 2, 4886, 4887, 9, 6, 2, 2, 4887, 937, 3, 2, 2, 2, 4888, 4889, 9, 17, 2, 2, 4889, 4890, 9, 10, 2, 2, 4890, 4891, 9, 6, 2, 2, 4891, 4892, 9, 6, 2, 2, 4892, 4893, 9, 4, 2, 2, 4893, 4894, 9, 21, 2, 2, 4894, 4895, 9, 10, 2, 2, 4895, 4896, 9, 13, 2, 2, 4896, 939, 3, 2, 2, 2, 4897, 4898, 9, 20, 2, 2, 4898, 4899, 9, 2, 2, 2, 4899, 4900, 9, 7, 2, 2, 4900, 4901, 9, 20, 2, 2, 4901, 941, 3, 2, 2, 2, 4902, 4903, 9, 20, 2, 2, 4903, 4904, 9, 2, 2, 2, 4904, 4905, 9, 7, 2, 2, 4905, 4906, 9, 20, 2, 2, 4906, 4907, 9, 10, 2, 2, 4907, 4908, 9, 7, 2, 2, 4908, 943, 3, 2, 2, 2, 4909, 4910, 9, 20, 2, 2, 4910, 4911, 9, 10, 2, 2, 4911, 4912, 9, 2, 2, 2, 4912, 4913, 9, 14, 2, 2, 4913, 4914, 9, 8, 2, 2, 4914, 4915, 9, 12, 2, 2, 4915, 4916, 9, 13, 2, 2, 4916, 4917, 9, 10, 2, 2, 4917, 945, 3, 2, 2, 2, 4918, 4919, 9, 20, 2, 2, 4919, 4920, 9, 19, 2, 2, 4920, 4921, 9, 22, 2, 2, 4921, 4922, 9, 4, 2, 2, 4922, 4923, 9, 6, 2, 2, 4923, 4924, 9, 20, 2, 2, 4924, 4925, 9, 10, 2, 2, 4925, 4926, 9, 6, 2, 2, 4926, 4927, 9, 12, 2, 2, 4927, 4928, 9, 11, 2, 2, 4928, 4929, 9, 2, 2, 2, 4929, 4930, 9, 8, 2, 2, 4930, 947, 3, 2, 2, 2, 4931, 4932, 9, 12, 2, 2, 4932, 4933, 9, 13, 2, 2, 4933, 4934, 9, 14, 2, 2, 4934, 4935, 9, 10, 2, 2, 4935, 4936, 9, 24, 2, 2, 4936, 4937, 5, 1152, 576, 2, 4937, 4938, 9, 11, 2, 2, 4938, 4939, 9, 8, 2, 2, 4939, 4940, 9, 10, 2, 2, 4940, 4941, 9, 2, 2, 2, 4941, 4942, 9, 13, 2, 2, 4942, 4943, 9, 9, 2, 2, 4943, 4944, 9, 22, 2, 2, 4944, 949, 3, 2, 2, 2, 4945, 4946, 9, 12, 2, 2, 4946, 4947, 9, 13, 2, 2, 4947, 4948, 9, 12, 2, 2, 4948, 4949, 9, 6, 2, 2, 4949, 951, 3, 2, 2, 2, 4950, 4951, 9, 12, 2, 2, 4951, 4952, 9, 13, 2, 2, 4952, 4953, 9, 12, 2, 2, 4953, 4954, 9, 6, 2, 2, 4954, 4955, 9, 11, 2, 2, 4955, 4956, 9, 4, 2, 2, 4956, 4957, 9, 13, 2, 2, 4957, 4958, 9, 14, 2, 2, 4958, 953, 3, 2, 2, 2, 4959, 4960, 9, 12, 2, 2, 4960, 4961, 9, 13, 2, 2, 4961, 4962, 9, 6, 2, 2, 4962, 4963, 9, 10, 2, 2, 4963, 4964, 9, 5, 2, 2, 4964, 4965, 9, 13, 2, 2, 4965, 4966, 9, 2, 2, 2, 4966, 4967, 9, 8, 2, 2, 4967, 4968, 9, 8, 2, 2, 4968, 4969, 9, 10, 2, 2, 4969, 4970, 9, 13, 2, 2, 4970, 4971, 9, 17, 2, 2, 4971, 4972, 9, 6, 2, 2, 4972, 4973, 9, 20, 2, 2, 4973, 955, 3, 2, 2, 2, 4974, 4975, 9, 26, 2, 2, 4975, 4976, 9, 7, 2, 2, 4976, 4977, 9, 4, 2, 2, 4977, 4978, 9, 13, 2, 2, 4978, 957, 3, 2, 2, 2, 4979, 4980, 9, 8, 2, 2, 4980, 4981, 9, 11, 2, 2, 4981, 4982, 5, 1152, 576, 2, 4982, 4983, 9, 11, 2, 2, 4983, 4984, 9, 4, 2, 2, 4984, 4985, 9, 8, 2, 2, 4985, 4986, 9, 8, 2, 2, 4986, 4987, 9, 2, 2, 2, 4987, 4988, 9, 6, 2, 2, 4988, 4989, 9, 10, 2, 2, 4989, 959, 3, 2, 2, 2, 4990, 4991, 9, 8, 2, 2, 4991, 4992, 9, 11, 2, 2, 4992, 4993, 5, 1152, 576, 2, 4993, 4994, 9, 11, 2, 2, 4994, 4995, 9, 6, 2, 2, 4995, 4996, 9, 19, 2, 2, 4996, 4997, 9, 22, 2, 2, 4997, 4998, 9, 10, 2, 2, 4998, 961, 3, 2, 2, 2, 4999, 5000, 9, 8, 2, 2, 5000, 5001, 9, 10, 2, 2, 5001, 5002, 9, 16, 2, 2, 5002, 5003, 9, 6, 2, 2, 5003, 5004, 9, 2, 2, 2, 5004, 5005, 9, 5, 2, 2, 5005, 5006, 9, 17, 2, 2, 5006, 963, 3, 2, 2, 2, 5007, 5008, 9, 8, 2, 2, 5008, 5009, 9, 10, 2, 2, 5009, 5010, 9, 24, 2, 2, 5010, 5011, 9, 12, 2, 2, 5011, 5012, 9, 25, 2, 2, 5012, 5013, 9, 10, 2, 2, 5013, 965, 3, 2, 2, 2, 5014, 5015, 9, 8, 2, 2, 5015, 5016, 9, 10, 2, 2, 5016, 5017, 9, 24, 2, 2, 5017, 5018, 9, 6, 2, 2, 5018, 5019, 9, 19, 2, 2, 5019, 5020, 9, 22, 2, 2, 5020, 5021, 9, 10, 2, 2, 5021, 5022, 9, 7, 2, 2, 5022, 967, 3, 2, 2, 2, 5023, 5024, 9, 8, 2, 2, 5024, 5025, 9, 12, 2, 2, 5025, 5026, 9, 7, 2, 2, 5026, 5027, 9, 6, 2, 2, 5027, 969, 3, 2, 2, 2, 5028, 5029, 9, 8, 2, 2, 5029, 5030, 9, 4, 2, 2, 5030, 5031, 9, 11, 2, 2, 5031, 5032, 9, 2, 2, 2, 5032, 5033, 9, 8, 2, 2, 5033, 5034, 9, 10, 2, 2, 5034, 971, 3, 2, 2, 2, 5035, 5036, 9, 8, 2, 2, 5036, 5037, 9, 4, 2, 2, 5037, 5038, 9, 17, 2, 2, 5038, 5039, 9, 12, 2, 2, 5039, 5040, 9, 13, 2, 2, 5040, 973, 3, 2, 2, 2, 5041, 5042, 9, 15, 2, 2, 5042, 5043, 9, 2, 2, 2, 5043, 5044, 9, 12, 2, 2, 5044, 5045, 9, 13, 2, 2, 5045, 975, 3, 2, 2, 2, 5046, 5047, 9, 15, 2, 2, 5047, 5048, 9, 10, 2, 2, 5048, 5049, 9, 5, 2, 2, 5049, 5050, 9, 17, 2, 2, 5050, 5051, 9, 10, 2, 2, 5051, 5052, 9, 7, 2, 2, 5052, 977, 3, 2, 2, 2, 5053, 5054, 9, 15, 2, 2, 5054, 5055, 9, 16, 2, 2, 5055, 5056, 9, 12, 2, 2, 5056, 5057, 9, 13, 2, 2, 5057, 5058, 9, 2, 2, 2, 5058, 5059, 9, 8, 2, 2, 5059, 5060, 9, 16, 2, 2, 5060, 5061, 9, 9, 2, 2, 5061, 5062, 9, 13, 2, 2, 5062, 5063, 9, 11, 2, 2, 5063, 979, 3, 2, 2, 2, 5064, 5065, 5, 978, 489, 2, 5065, 5066, 5, 1152, 576, 2, 5066, 5067, 9, 10, 2, 2, 5067, 5068, 9, 24, 2, 2, 5068, 5069, 9, 6, 2, 2, 5069, 5070, 9, 5, 2, 2, 5070, 5071, 9, 2, 2, 2, 5071, 981, 3, 2, 2, 2, 5072, 5073, 5, 978, 489, 2, 5073, 5074, 5, 1152, 576, 2, 5074, 5075, 9, 15, 2, 2, 5075, 5076, 9, 4, 2, 2, 5076, 5077, 9, 14, 2, 2, 5077, 5078, 9, 12, 2, 2, 5078, 5079, 9, 16, 2, 2, 5079, 5080, 9, 19, 2, 2, 5080, 983, 3, 2, 2, 2, 5081, 5082, 9, 15, 2, 2, 5082, 5083, 9, 12, 2, 2, 5083, 5084, 9, 13, 2, 2, 5084, 5085, 9, 12, 2, 2, 5085, 5086, 9, 6, 2, 2, 5086, 5087, 9, 11, 2, 2, 5087, 5088, 9, 4, 2, 2, 5088, 5089, 9, 13, 2, 2, 5089, 5090, 9, 14, 2, 2, 5090, 985, 3, 2, 2, 2, 5091, 5092, 9, 15, 2, 2, 5092, 5093, 9, 12, 2, 2, 5093, 5094, 9, 13, 2, 2, 5094, 5095, 9, 23, 2, 2, 5095, 5096, 9, 16, 2, 2, 5096, 5097, 9, 9, 2, 2, 5097, 5098, 9, 13, 2, 2, 5098, 5099, 9, 11, 2, 2, 5099, 987, 3, 2, 2, 2, 5100, 5101, 9, 15, 2, 2, 5101, 5102, 9, 4, 2, 2, 5102, 5103, 9, 14, 2, 2, 5103, 5104, 9, 9, 2, 2, 5104, 5105, 9, 8, 2, 2, 5105, 5106, 9, 9, 2, 2, 5106, 5107, 9, 7, 2, 2, 5107, 989, 3, 2, 2, 2, 5108, 5109, 9, 15, 2, 2, 5109, 5110, 9, 7, 2, 2, 5110, 5111, 9, 16, 2, 2, 5111, 5112, 9, 9, 2, 2, 5112, 5113, 9, 13, 2, 2, 5113, 5114, 9, 11, 2, 2, 5114, 991, 3, 2, 2, 2, 5115, 5116, 9, 15, 2, 2, 5116, 5117, 9, 7, 2, 2, 5117, 5118, 9, 7, 2, 2, 5118, 5119, 9, 22, 2, 2, 5119, 5120, 9, 2, 2, 2, 5120, 5121, 9, 11, 2, 2, 5121, 5122, 9, 10, 2, 2, 5122, 993, 3, 2, 2, 2, 5123, 5124, 9, 15, 2, 2, 5124, 5125, 9, 7, 2, 2, 5125, 5126, 9, 6, 2, 2, 5126, 5127, 9, 19, 2, 2, 5127, 5128, 9, 22, 2, 2, 5128, 5129, 9, 10, 2, 2, 5129, 995, 3, 2, 2, 2, 5130, 5131, 9, 13, 2, 2, 5131, 5132, 9, 10, 2, 2, 5132, 5133, 9, 17, 2, 2, 5133, 5134, 9, 2, 2, 2, 5134, 5135, 9, 6, 2, 2, 5135, 5136, 9, 4, 2, 2, 5136, 5137, 9, 5, 2, 2, 5137, 997, 3, 2, 2, 2, 5138, 5139, 9, 13, 2, 2, 5139, 5140, 9, 4, 2, 2, 5140, 5141, 9, 3, 2, 2, 5141, 5142, 9, 19, 2, 2, 5142, 5143, 9, 22, 2, 2, 5143, 5144, 9, 2, 2, 2, 5144, 5145, 9, 7, 2, 2, 5145, 5146, 9, 7, 2, 2, 5146, 5147, 9, 5, 2, 2, 5147, 5148, 9, 8, 2, 2, 5148, 5149, 9, 7, 2, 2, 5149, 999, 3, 2, 2, 2, 5150, 5151, 9, 13, 2, 2, 5151, 5152, 9, 4, 2, 2, 5152, 5153, 9, 11, 2, 2, 5153, 5154, 9, 5, 2, 2, 5154, 5155, 9, 10, 2, 2, 5155, 5156, 9, 2, 2, 2, 5156, 5157, 9, 6, 2, 2, 5157, 5158, 9, 10, 2, 2, 5158, 5159, 9, 14, 2, 2, 5159, 5160, 9, 3, 2, 2, 5160, 1001, 3, 2, 2, 2, 5161, 5162, 9, 13, 2, 2, 5162, 5163, 9, 4, 2, 2, 5163, 5164, 9, 11, 2, 2, 5164, 5165, 9, 5, 2, 2, 5165, 5166, 9, 10, 2, 2, 5166, 5167, 9, 2, 2, 2, 5167, 5168, 9, 6, 2, 2, 5168, 5169, 9, 10, 2, 2, 5169, 5170, 9, 5, 2, 2, 5170, 5171, 9, 4, 2, 2, 5171, 5172, 9, 8, 2, 2, 5172, 5173, 9, 10, 2, 2, 5173, 1003, 3, 2, 2, 2, 5174, 5175, 9, 13, 2, 2, 5175, 5176, 9, 4, 2, 2, 5176, 5177, 9, 12, 2, 2, 5177, 5178, 9, 13, 2, 2, 5178, 5179, 9, 20, 2, 2, 5179, 5180, 9, 10, 2, 2, 5180, 5181, 9, 5, 2, 2, 5181, 5182, 9, 12, 2, 2, 5182, 5183, 9, 6, 2, 2, 5183, 1005, 3, 2, 2, 2, 5184, 5185, 9, 13, 2, 2, 5185, 5186, 9, 4, 2, 2, 5186, 5187, 9, 8, 2, 2, 5187, 5188, 9, 4, 2, 2, 5188, 5189, 9, 17, 2, 2, 5189, 5190, 9, 12, 2, 2, 5190, 5191, 9, 13, 2, 2, 5191, 1007, 3, 2, 2, 2, 5192, 5193, 9, 13, 2, 2, 5193, 5194, 9, 4, 2, 2, 5194, 5195, 9, 5, 2, 2, 5195, 5196, 9, 10, 2, 2, 5196, 5197, 9, 22, 2, 2, 5197, 5198, 9, 8, 2, 2, 5198, 5199, 9, 12, 2, 2, 5199, 5200, 9, 11, 2, 2, 5200, 5201, 9, 2, 2, 2, 5201, 5202, 9, 6, 2, 2, 5202, 5203, 9, 12, 2, 2, 5203, 5204, 9, 4, 2, 2, 5204, 5205, 9, 13, 2, 2, 5205, 1009, 3, 2, 2, 2, 5206, 5207, 9, 13, 2, 2, 5207, 5208, 9, 4, 2, 2, 5208, 5209, 9, 7, 2, 2, 5209, 5210, 9, 9, 2, 2, 5210, 5211, 9, 22, 2, 2, 5211, 5212, 9, 10, 2, 2, 5212, 5213, 9, 5, 2, 2, 5213, 5214, 9, 9, 2, 2, 5214, 5215, 9, 7, 2, 2, 5215, 5216, 9, 10, 2, 2, 5216, 5217, 9, 5, 2, 2, 5217, 1011, 3, 2, 2, 2, 5218, 5219, 9, 4, 2, 2, 5219, 5220, 9, 9, 2, 2, 5220, 5221, 9, 6, 2, 2, 5221, 5222, 9, 22, 2, 2, 5222, 5223, 9, 9, 2, 2, 5223, 5224, 9, 6, 2, 2, 5224, 1013, 3, 2, 2, 2, 5225, 5226, 9, 22, 2, 2, 5226, 5227, 9, 2, 2, 2, 5227, 5228, 9, 7, 2, 2, 5228, 5229, 9, 7, 2, 2, 5229, 5230, 9, 10, 2, 2, 5230, 5231, 9, 14, 2, 2, 5231, 5232, 9, 3, 2, 2, 5232, 5233, 9, 19, 2, 2, 5233, 5234, 9, 23, 2, 2, 5234, 5235, 9, 2, 2, 2, 5235, 5236, 9, 8, 2, 2, 5236, 5237, 9, 9, 2, 2, 5237, 5238, 9, 10, 2, 2, 5238, 1015, 3, 2, 2, 2, 5239, 5240, 9, 22, 2, 2, 5240, 5241, 9, 2, 2, 2, 5241, 5242, 9, 6, 2, 2, 5242, 5243, 9, 20, 2, 2, 5243, 1017, 3, 2, 2, 2, 5244, 5245, 9, 22, 2, 2, 5245, 5246, 9, 10, 2, 2, 5246, 5247, 9, 5, 2, 2, 5247, 5248, 9, 15, 2, 2, 5248, 5249, 9, 12, 2, 2, 5249, 5250, 9, 7, 2, 2, 5250, 5251, 9, 7, 2, 2, 5251, 5252, 9, 12, 2, 2, 5252, 5253, 9, 23, 2, 2, 5253, 5254, 9, 10, 2, 2, 5254, 1019, 3, 2, 2, 2, 5255, 5256, 9, 22, 2, 2, 5256, 5257, 9, 8, 2, 2, 5257, 5258, 9, 2, 2, 2, 5258, 5259, 9, 12, 2, 2, 5259, 5260, 9, 13, 2, 2, 5260, 1021, 3, 2, 2, 2, 5261, 5262, 9, 22, 2, 2, 5262, 5263, 9, 5, 2, 2, 5263, 5264, 9, 10, 2, 2, 5264, 5265, 9, 16, 2, 2, 5265, 5266, 9, 10, 2, 2, 5266, 5267, 9, 5, 2, 2, 5267, 5268, 9, 5, 2, 2, 5268, 5269, 9, 10, 2, 2, 5269, 5270, 9, 14, 2, 2, 5270, 1023, 3, 2, 2, 2, 5271, 5272, 9, 22, 2, 2, 5272, 5273, 9, 5, 2, 2, 5273, 5274, 9, 4, 2, 2, 5274, 5275, 9, 23, 2, 2, 5275, 5276, 9, 12, 2, 2, 5276, 5277, 9, 14, 2, 2, 5277, 5278, 9, 10, 2, 2, 5278, 5279, 9, 5, 2, 2, 5279, 1025, 3, 2, 2, 2, 5280, 5281, 5, 382, 191, 2, 5281, 5282, 5, 1152, 576, 2, 5282, 5283, 5, 838, 419, 2, 5283, 1027, 3, 2, 2, 2, 5284, 5285, 5, 382, 191, 2, 5285, 5286, 5, 1152, 576, 2, 5286, 5287, 5, 578, 289, 2, 5287, 1029, 3, 2, 2, 2, 5288, 5289, 9, 5, 2, 2, 5289, 5290, 9, 10, 2, 2, 5290, 5291, 9, 11, 2, 2, 5291, 5292, 9, 10, 2, 2, 5292, 5293, 9, 12, 2, 2, 5293, 5294, 9, 23, 2, 2, 5294, 5295, 9, 10, 2, 2, 5295, 1031, 3, 2, 2, 2, 5296, 5297, 9, 5, 2, 2, 5297, 5298, 9, 10, 2, 2, 5298, 5299, 9, 15, 2, 2, 5299, 5300, 9, 2, 2, 2, 5300, 5301, 9, 12, 2, 2, 5301, 5302, 9, 13, 2, 2, 5302, 5303, 9, 14, 2, 2, 5303, 5304, 9, 10, 2, 2, 5304, 5305, 9, 5, 2, 2, 5305, 1033, 3, 2, 2, 2, 5306, 5307, 9, 5, 2, 2, 5307, 5308, 9, 10, 2, 2, 5308, 5309, 9, 22, 2, 2, 5309, 5310, 9, 8, 2, 2, 5310, 5311, 9, 12, 2, 2, 5311, 5312, 9, 11, 2, 2, 5312, 5313, 9, 2, 2, 2, 5313, 5314, 9, 6, 2, 2, 5314, 5315, 9, 12, 2, 2, 5315, 5316, 9, 4, 2, 2, 5316, 5317, 9, 13, 2, 2, 5317, 1035, 3, 2, 2, 2, 5318, 5319, 9, 5, 2, 2, 5319, 5320, 9, 10, 2, 2, 5320, 5321, 9, 7, 2, 2, 5321, 5322, 9, 6, 2, 2, 5322, 5323, 9, 5, 2, 2, 5323, 5324, 9, 12, 2, 2, 5324, 5325, 9, 11, 2, 2, 5325, 5326, 9, 6, 2, 2, 5326, 5327, 9, 10, 2, 2, 5327, 5328, 9, 14, 2, 2, 5328, 1037, 3, 2, 2, 2, 5329, 5330, 9, 5, 2, 2, 5330, 5331, 9, 10, 2, 2, 5331, 5332, 9, 7, 2, 2, 5332, 5333, 9, 6, 2, 2, 5333, 5334, 9, 5, 2, 2, 5334, 5335, 9, 12, 2, 2, 5335, 5336, 9, 11, 2, 2, 5336, 5337, 9, 6, 2, 2, 5337, 5338, 9, 12, 2, 2, 5338, 5339, 9, 23, 2, 2, 5339, 5340, 9, 10, 2, 2, 5340, 1039, 3, 2, 2, 2, 5341, 5342, 9, 5, 2, 2, 5342, 5343, 9, 12, 2, 2, 5343, 5344, 9, 17, 2, 2, 5344, 5345, 9, 20, 2, 2, 5345, 5346, 9, 6, 2, 2, 5346, 5347, 9, 2, 2, 2, 5347, 5348, 9, 5, 2, 2, 5348, 5349, 9, 17, 2, 2, 5349, 1041, 3, 2, 2, 2, 5350, 5351, 9, 7, 2, 2, 5351, 5352, 9, 2, 2, 2, 5352, 5353, 9, 16, 2, 2, 5353, 5354, 9, 10, 2, 2, 5354, 1043, 3, 2, 2, 2, 5355, 5356, 9, 7, 2, 2, 5356, 5357, 9, 10, 2, 2, 5357, 5358, 9, 13, 2, 2, 5358, 5359, 9, 14, 2, 2, 5359, 1045, 3, 2, 2, 2, 5360, 5361, 9, 7, 2, 2, 5361, 5362, 9, 10, 2, 2, 5362, 5363, 9, 5, 2, 2, 5363, 5364, 9, 12, 2, 2, 5364, 5365, 9, 2, 2, 2, 5365, 5366, 9, 8, 2, 2, 5366, 5367, 9, 16, 2, 2, 5367, 5368, 9, 9, 2, 2, 5368, 5369, 9, 13, 2, 2, 5369, 5370, 9, 11, 2, 2, 5370, 1047, 3, 2, 2, 2, 5371, 5372, 9, 7, 2, 2, 5372, 5373, 9, 10, 2, 2, 5373, 5374, 9, 6, 2, 2, 5374, 5375, 9, 6, 2, 2, 5375, 5376, 9, 12, 2, 2, 5376, 5377, 9, 13, 2, 2, 5377, 5378, 9, 17, 2, 2, 5378, 5379, 9, 7, 2, 2, 5379, 1049, 3, 2, 2, 2, 5380, 5381, 9, 7, 2, 2, 5381, 5382, 9, 16, 2, 2, 5382, 5383, 9, 9, 2, 2, 5383, 5384, 9, 13, 2, 2, 5384, 5385, 9, 11, 2, 2, 5385, 1051, 3, 2, 2, 2, 5386, 5387, 9, 7, 2, 2, 5387, 5388, 9, 20, 2, 2, 5388, 5389, 9, 2, 2, 2, 5389, 5390, 9, 5, 2, 2, 5390, 5391, 9, 10, 2, 2, 5391, 5392, 9, 2, 2, 2, 5392, 5393, 9, 3, 2, 2, 5393, 5394, 9, 8, 2, 2, 5394, 5395, 9, 10, 2, 2, 5395, 1053, 3, 2, 2, 2, 5396, 5397, 9, 7, 2, 2, 5397, 5398, 9, 21, 2, 2, 5398, 5399, 9, 12, 2, 2, 5399, 5400, 9, 22, 2, 2, 5400, 5401, 5, 1152, 576, 2, 5401, 5402, 9, 8, 2, 2, 5402, 5403, 9, 4, 2, 2, 5403, 5404, 9, 11, 2, 2, 5404, 5405, 9, 21, 2, 2, 5405, 5406, 9, 10, 2, 2, 5406, 5407, 9, 14, 2, 2, 5407, 1055, 3, 2, 2, 2, 5408, 5409, 9, 7, 2, 2, 5409, 5410, 9, 4, 2, 2, 5410, 5411, 9, 5, 2, 2, 5411, 5412, 9, 6, 2, 2, 5412, 5413, 9, 4, 2, 2, 5413, 5414, 9, 22, 2, 2, 5414, 1057, 3, 2, 2, 2, 5415, 5416, 9, 7, 2, 2, 5416, 5417, 9, 7, 2, 2, 5417, 5418, 9, 22, 2, 2, 5418, 5419, 9, 2, 2, 2, 5419, 5420, 9, 11, 2, 2, 5420, 5421, 9, 10, 2, 2, 5421, 1059, 3, 2, 2, 2, 5422, 5423, 9, 7, 2, 2, 5423, 5424, 9, 6, 2, 2, 5424, 5425, 9, 19, 2, 2, 5425, 5426, 9, 22, 2, 2, 5426, 5427, 9, 10, 2, 2, 5427, 1061, 3, 2, 2, 2, 5428, 5429, 9, 7, 2, 2, 5429, 5430, 9, 9, 2, 2, 5430, 5431, 9, 3, 2, 2, 5431, 5432, 9, 6, 2, 2, 5432, 5433, 9, 19, 2, 2, 5433, 5434, 9, 22, 2, 2, 5434, 5435, 9, 10, 2, 2, 5435, 5436, 5, 1152, 576, 2, 5436, 5437, 9, 14, 2, 2, 5437, 5438, 9, 12, 2, 2, 5438, 5439, 9, 16, 2, 2, 5439, 5440, 9, 16, 2, 2, 5440, 1063, 3, 2, 2, 2, 5441, 5442, 9, 7, 2, 2, 5442, 5443, 9, 9, 2, 2, 5443, 5444, 9, 3, 2, 2, 5444, 5445, 9, 6, 2, 2, 5445, 5446, 9, 19, 2, 2, 5446, 5447, 9, 22, 2, 2, 5447, 5448, 9, 10, 2, 2, 5448, 5449, 5, 1152, 576, 2, 5449, 5450, 9, 4, 2, 2, 5450, 5451, 9, 22, 2, 2, 5451, 5452, 9, 11, 2, 2, 5452, 5453, 9, 8, 2, 2, 5453, 5454, 9, 2, 2, 2, 5454, 5455, 9, 7, 2, 2, 5455, 5456, 9, 7, 2, 2, 5456, 1065, 3, 2, 2, 2, 5457, 5458, 9, 7, 2, 2, 5458, 5459, 9, 9, 2, 2, 5459, 5460, 9, 3, 2, 2, 5460, 5461, 9, 6, 2, 2, 5461, 5462, 9, 19, 2, 2, 5462, 5463, 9, 22, 2, 2, 5463, 5464, 9, 10, 2, 2, 5464, 1067, 3, 2, 2, 2, 5465, 5466, 9, 7, 2, 2, 5466, 5467, 9, 9, 2, 2, 5467, 5468, 9, 15, 2, 2, 5468, 5469, 9, 15, 2, 2, 5469, 5470, 9, 2, 2, 2, 5470, 5471, 9, 5, 2, 2, 5471, 5472, 9, 19, 2, 2, 5472, 1069, 3, 2, 2, 2, 5473, 5474, 9, 7, 2, 2, 5474, 5475, 9, 9, 2, 2, 5475, 5476, 9, 22, 2, 2, 5476, 5477, 9, 10, 2, 2, 5477, 5478, 9, 5, 2, 2, 5478, 5479, 9, 9, 2, 2, 5479, 5480, 9, 7, 2, 2, 5480, 5481, 9, 10, 2, 2, 5481, 5482, 9, 5, 2, 2, 5482, 1071, 3, 2, 2, 2, 5483, 5484, 9, 6, 2, 2, 5484, 5485, 9, 12, 2, 2, 5485, 5486, 9, 15, 2, 2, 5486, 5487, 9, 12, 2, 2, 5487, 5488, 9, 13, 2, 2, 5488, 5489, 9, 17, 2, 2, 5489, 1073, 3, 2, 2, 2, 5490, 5491, 9, 6, 2, 2, 5491, 5492, 9, 19, 2, 2, 5492, 5493, 9, 22, 2, 2, 5493, 5494, 9, 15, 2, 2, 5494, 5495, 9, 4, 2, 2, 5495, 5496, 9, 14, 2, 2, 5496, 5497, 5, 1152, 576, 2, 5497, 5498, 9, 12, 2, 2, 5498, 5499, 9, 13, 2, 2, 5499, 1075, 3, 2, 2, 2, 5500, 5501, 9, 6, 2, 2, 5501, 5502, 9, 19, 2, 2, 5502, 5503, 9, 22, 2, 2, 5503, 5504, 9, 15, 2, 2, 5504, 5505, 9, 4, 2, 2, 5505, 5506, 9, 14, 2, 2, 5506, 5507, 5, 1152, 576, 2, 5507, 5508, 9, 4, 2, 2, 5508, 5509, 9, 9, 2, 2, 5509, 5510, 9, 6, 2, 2, 5510, 1077, 3, 2, 2, 2, 5511, 5512, 9, 9, 2, 2, 5512, 5513, 9, 13, 2, 2, 5513, 5514, 9, 7, 2, 2, 5514, 5515, 9, 2, 2, 2, 5515, 5516, 9, 16, 2, 2, 5516, 5517, 9, 10, 2, 2, 5517, 1079, 3, 2, 2, 2, 5518, 5519, 9, 9, 2, 2, 5519, 5520, 9, 7, 2, 2, 5520, 5521, 9, 2, 2, 2, 5521, 5522, 9, 17, 2, 2, 5522, 5523, 9, 10, 2, 2, 5523, 1081, 3, 2, 2, 2, 5524, 5525, 9, 23, 2, 2, 5525, 5526, 9, 2, 2, 2, 5526, 5527, 9, 5, 2, 2, 5527, 5528, 9, 12, 2, 2, 5528, 5529, 9, 2, 2, 2, 5529, 5530, 9, 3, 2, 2, 5530, 5531, 9, 8, 2, 2, 5531, 5532, 9, 10, 2, 2, 5532, 1083, 3, 2, 2, 2, 5533, 5534, 9, 19, 2, 2, 5534, 5535, 9, 2, 2, 2, 5535, 5536, 9, 15, 2, 2, 5536, 5537, 9, 8, 2, 2, 5537, 1085, 3, 2, 2, 2, 5538, 5539, 9, 2, 2, 2, 5539, 5540, 9, 8, 2, 2, 5540, 5541, 9, 12, 2, 2, 5541, 5542, 9, 2, 2, 2, 5542, 5543, 9, 7, 2, 2, 5543, 1087, 3, 2, 2, 2, 5544, 5545, 9, 2, 2, 2, 5545, 5546, 9, 7, 2, 2, 5546, 5547, 9, 7, 2, 2, 5547, 5548, 9, 10, 2, 2, 5548, 5549, 9, 5, 2, 2, 5549, 5550, 9, 6, 2, 2, 5550, 1089, 3, 2, 2, 2, 5551, 5552, 9, 11, 2, 2, 5552, 5553, 9, 4, 2, 2, 5553, 5554, 9, 13, 2, 2, 5554, 5555, 9, 7, 2, 2, 5555, 5556, 9, 6, 2, 2, 5556, 5557, 9, 2, 2, 2, 5557, 5558, 9, 13, 2, 2, 5558, 5559, 9, 6, 2, 2, 5559, 1091, 3, 2, 2, 2, 5560, 5561, 9, 14, 2, 2, 5561, 5562, 9, 2, 2, 2, 5562, 5563, 9, 6, 2, 2, 5563, 5564, 9, 2, 2, 2, 5564, 5565, 9, 6, 2, 2, 5565, 5566, 9, 19, 2, 2, 5566, 5567, 9, 22, 2, 2, 5567, 5568, 9, 10, 2, 2, 5568, 1093, 3, 2, 2, 2, 5569, 5570, 9, 14, 2, 2, 5570, 5571, 9, 10, 2, 2, 5571, 5572, 9, 3, 2, 2, 5572, 5573, 9, 9, 2, 2, 5573, 5574, 9, 17, 2, 2, 5574, 1095, 3, 2, 2, 2, 5575, 5576, 9, 14, 2, 2, 5576, 5577, 9, 10, 2, 2, 5577, 5578, 9, 6, 2, 2, 5578, 5579, 9, 2, 2, 2, 5579, 5580, 9, 12, 2, 2, 5580, 5581, 9, 8, 2, 2, 5581, 1097, 3, 2, 2, 2, 5582, 5583, 9, 14, 2, 2, 5583, 5584, 9, 12, 2, 2, 5584, 5585, 9, 2, 2, 2, 5585, 5586, 9, 17, 2, 2, 5586, 5587, 9, 13, 2, 2, 5587, 5588, 9, 4, 2, 2, 5588, 5589, 9, 7, 2, 2, 5589, 5590, 9, 6, 2, 2, 5590, 5591, 9, 12, 2, 2, 5591, 5592, 9, 11, 2, 2, 5592, 5593, 9, 7, 2, 2, 5593, 1099, 3, 2, 2, 2, 5594, 5595, 9, 10, 2, 2, 5595, 5596, 9, 8, 2, 2, 5596, 5597, 9, 7, 2, 2, 5597, 5598, 9, 10, 2, 2, 5598, 5599, 9, 12, 2, 2, 5599, 5600, 9, 16, 2, 2, 5600, 1101, 3, 2, 2, 2, 5601, 5602, 9, 10, 2, 2, 5602, 5603, 9, 8, 2, 2, 5603, 5604, 9, 7, 2, 2, 5604, 5605, 9, 12, 2, 2, 5605, 5606, 9, 16, 2, 2, 5606, 1103, 3, 2, 2, 2, 5607, 5608, 9, 10, 2, 2, 5608, 5609, 9, 5, 2, 2, 5609, 5610, 9, 5, 2, 2, 5610, 5611, 9, 11, 2, 2, 5611, 5612, 9, 4, 2, 2, 5612, 5613, 9, 14, 2, 2, 5613, 5614, 9, 10, 2, 2, 5614, 1105, 3, 2, 2, 2, 5615, 5616, 9, 10, 2, 2, 5616, 5617, 9, 24, 2, 2, 5617, 5618, 9, 12, 2, 2, 5618, 5619, 9, 6, 2, 2, 5619, 1107, 3, 2, 2, 2, 5620, 5621, 9, 10, 2, 2, 5621, 5622, 9, 24, 2, 2, 5622, 5623, 9, 11, 2, 2, 5623, 5624, 9, 10, 2, 2, 5624, 5625, 9, 22, 2, 2, 5625, 5626, 9, 6, 2, 2, 5626, 5627, 9, 12, 2, 2, 5627, 5628, 9, 4, 2, 2, 5628, 5629, 9, 13, 2, 2, 5629, 1109, 3, 2, 2, 2, 5630, 5631, 9, 16, 2, 2, 5631, 5632, 9, 4, 2, 2, 5632, 5633, 9, 5, 2, 2, 5633, 5634, 9, 10, 2, 2, 5634, 5635, 9, 2, 2, 2, 5635, 5636, 9, 11, 2, 2, 5636, 5637, 9, 20, 2, 2, 5637, 1111, 3, 2, 2, 2, 5638, 5639, 9, 17, 2, 2, 5639, 5640, 9, 10, 2, 2, 5640, 5641, 9, 6, 2, 2, 5641, 1113, 3, 2, 2, 2, 5642, 5643, 9, 20, 2, 2, 5643, 5644, 9, 12, 2, 2, 5644, 5645, 9, 13, 2, 2, 5645, 5646, 9, 6, 2, 2, 5646, 1115, 3, 2, 2, 2, 5647, 5648, 9, 12, 2, 2, 5648, 5649, 9, 13, 2, 2, 5649, 5650, 9, 16, 2, 2, 5650, 5651, 9, 4, 2, 2, 5651, 1117, 3, 2, 2, 2, 5652, 5653, 9, 8, 2, 2, 5653, 5654, 9, 4, 2, 2, 5654, 5655, 9, 17, 2, 2, 5655, 1119, 3, 2, 2, 2, 5656, 5657, 9, 8, 2, 2, 5657, 5658, 9, 4, 2, 2, 5658, 5659, 9, 4, 2, 2, 5659, 5660, 9, 22, 2, 2, 5660, 1121, 3, 2, 2, 2, 5661, 5662, 9, 15, 2, 2, 5662, 5663, 9, 10, 2, 2, 5663, 5664, 9, 7, 2, 2, 5664, 5665, 9, 7, 2, 2, 5665, 5666, 9, 2, 2, 2, 5666, 5667, 9, 17, 2, 2, 5667, 5668, 9, 10, 2, 2, 5668, 1123, 3, 2, 2, 2, 5669, 5670, 9, 13, 2, 2, 5670, 5671, 9, 4, 2, 2, 5671, 5672, 9, 6, 2, 2, 5672, 5673, 9, 12, 2, 2, 5673, 5674, 9, 11, 2, 2, 5674, 5675, 9, 10, 2, 2, 5675, 1125, 3, 2, 2, 2, 5676, 5677, 9, 4, 2, 2, 5677, 5678, 9, 22, 2, 2, 5678, 5679, 9, 10, 2, 2, 5679, 5680, 9, 13, 2, 2, 5680, 1127, 3, 2, 2, 2, 5681, 5682, 9, 22, 2, 2, 5682, 5683, 9, 10, 2, 2, 5683, 5684, 9, 5, 2, 2, 5684, 5685, 9, 16, 2, 2, 5685, 5686, 9, 4, 2, 2, 5686, 5687, 9, 5, 2, 2, 5687, 5688, 9, 15, 2, 2, 5688, 1129, 3, 2, 2, 2, 5689, 5690, 9, 27, 2, 2, 5690, 5691, 9, 9, 2, 2, 5691, 5692, 9, 10, 2, 2, 5692, 5693, 9, 5, 2, 2, 5693, 5694, 9, 19, 2, 2, 5694, 1131, 3, 2, 2, 2, 5695, 5696, 9, 5, 2, 2, 5696, 5697, 9, 2, 2, 2, 5697, 5698, 9, 12, 2, 2, 5698, 5699, 9, 7, 2, 2, 5699, 5700, 9, 10, 2, 2, 5700, 1133, 3, 2, 2, 2, 5701, 5702, 9, 5, 2, 2, 5702, 5703, 9, 10, 2, 2, 5703, 5704, 9, 11, 2, 2, 5704, 5705, 9, 4, 2, 2, 5705, 5706, 9, 5, 2, 2, 5706, 5707, 9, 14, 2, 2, 5707, 1135, 3, 2, 2, 2, 5708, 5709, 9, 5, 2, 2, 5709, 5710, 9, 10, 2, 2, 5710, 5711, 9, 6, 2, 2, 5711, 5712, 9, 9, 2, 2, 5712, 5713, 9, 5, 2, 2, 5713, 5714, 9, 13, 2, 2, 5714, 1137, 3, 2, 2, 2, 5715, 5716, 9, 5, 2, 2, 5716, 5717, 9, 10, 2, 2, 5717, 5718, 9, 23, 2, 2, 5718, 5719, 9, 10, 2, 2, 5719, 5720, 9, 5, 2, 2, 5720, 5721, 9, 7, 2, 2, 5721, 5722, 9, 10, 2, 2, 5722, 1139, 3, 2, 2, 2, 5723, 5724, 9, 5, 2, 2, 5724, 5725, 9, 4, 2, 2, 5725, 5726, 9, 18, 2, 2, 5726, 5727, 9, 6, 2, 2, 5727, 5728, 9, 19, 2, 2, 5728, 5729, 9, 22, 2, 2, 5729, 5730, 9, 10, 2, 2, 5730, 1141, 3, 2, 2, 2, 5731, 5732, 9, 7, 2, 2, 5732, 5733, 9, 8, 2, 2, 5733, 5734, 9, 12, 2, 2, 5734, 5735, 9, 11, 2, 2, 5735, 5736, 9, 10, 2, 2, 5736, 1143, 3, 2, 2, 2, 5737, 5738, 9, 7, 2, 2, 5738, 5739, 9, 27, 2, 2, 5739, 5740, 9, 8, 2, 2, 5740, 5741, 9, 7, 2, 2, 5741, 5742, 9, 6, 2, 2, 5742, 5743, 9, 2, 2, 2, 5743, 5744, 9, 6, 2, 2, 5744, 5745, 9, 10, 2, 2, 5745, 1145, 3, 2, 2, 2, 5746, 5747, 9, 7, 2, 2, 5747, 5748, 9, 6, 2, 2, 5748, 5749, 9, 2, 2, 2, 5749, 5750, 9, 11, 2, 2, 5750, 5751, 9, 21, 2, 2, 5751, 5752, 9, 10, 2, 2, 5752, 5753, 9, 14, 2, 2, 5753, 1147, 3, 2, 2, 2, 5754, 5755, 9, 18, 2, 2, 5755, 5756, 9, 2, 2, 2, 5756, 5757, 9, 5, 2, 2, 5757, 5758, 9, 13, 2, 2, 5758, 5759, 9, 12, 2, 2, 5759, 5760, 9, 13, 2, 2, 5760, 5761, 9, 17, 2, 2, 5761, 1149, 3, 2, 2, 2, 5762, 5763, 9, 18, 2, 2, 5763, 5764, 9, 20, 2, 2, 5764, 5765, 9, 12, 2, 2, 5765, 5766, 9, 8, 2, 2, 5766, 5767, 9, 10, 2, 2, 5767, 1151, 3, 2, 2, 2, 5768, 5769, 7, 97, 2, 2, 5769, 1153, 3, 2, 2, 2, 5770, 5771, 7, 60, 2, 2, 5771, 5772, 7, 60, 2, 2, 5772, 1155, 3, 2, 2, 2, 5773, 5774, 7, 63, 2, 2, 5774, 1157, 3, 2, 2, 2, 5775, 5776, 7, 60, 2, 2, 5776, 1159, 3, 2, 2, 2, 5777, 5778, 7, 61, 2, 2, 5778, 1161, 3, 2, 2, 2, 5779, 5780, 7, 46, 2, 2, 5780, 1163, 3, 2, 2, 2, 5781, 5782, 7, 62, 2, 2, 5782, 5786, 7, 64, 2, 2, 5783, 5784, 7, 35, 2, 2, 5784, 5786, 7, 63, 2, 2, 5785, 5781, 3, 2, 2, 2, 5785, 5783, 3, 2, 2, 2, 5786, 1165, 3, 2, 2, 2, 5787, 5788, 7, 62, 2, 2, 5788, 1167, 3, 2, 2, 2, 5789, 5790, 7, 62, 2, 2, 5790, 5791, 7, 63, 2, 2, 5791, 1169, 3, 2, 2, 2, 5792, 5793, 7, 64, 2, 2, 5793, 1171, 3, 2, 2, 2, 5794, 5795, 7, 64, 2, 2, 5795, 5796, 7, 63, 2, 2, 5796, 1173, 3, 2, 2, 2, 5797, 5798, 7, 42, 2, 2, 5798, 1175, 3, 2, 2, 2, 5799, 5800, 7, 43, 2, 2, 5800, 1177, 3, 2, 2, 2, 5801, 5802, 7, 45, 2, 2, 5802, 1179, 3, 2, 2, 2, 5803, 5804, 7, 47, 2, 2, 5804, 1181, 3, 2, 2, 2, 5805, 5806, 7, 44, 2, 2, 5806, 1183, 3, 2, 2, 2, 5807, 5808, 7, 49, 2, 2, 5808, 1185, 3, 2, 2, 2, 5809, 5810, 7, 39, 2, 2, 5810, 1187, 3, 2, 2, 2, 5811, 5812, 7, 96, 2, 2, 5812, 1189, 3, 2, 2, 2, 5813, 5814, 7, 48, 2, 2, 5814, 1191, 3, 2, 2, 2, 5815, 5816, 7, 41, 2, 2, 5816, 1193, 3, 2, 2, 2, 5817, 5818, 7, 36, 2, 2, 5818, 1195, 3, 2, 2, 2, 5819, 5820, 7, 38, 2, 2, 5820, 1197, 3, 2, 2, 2, 5821, 5822, 7, 93, 2, 2, 5822, 1199, 3, 2, 2, 2, 5823, 5824, 7, 95, 2, 2, 5824, 1201, 3, 2, 2, 2, 5825, 5826, 7, 63, 2, 2, 5826, 5827, 7, 64, 2, 2, 5827, 1203, 3, 2, 2, 2, 5828, 5829, 7, 60, 2, 2, 5829, 5830, 7, 63, 2, 2, 5830, 1205, 3, 2, 2, 2, 5831, 5832, 7, 62, 2, 2, 5832, 5833, 7, 62, 2, 2, 5833, 1207, 3, 2, 2, 2, 5834, 5835, 7, 64, 2, 2, 5835, 5836, 7, 64, 2, 2, 5836, 1209, 3, 2, 2, 2, 5837, 5838, 7, 48, 2, 2, 5838, 5839, 7, 48, 2, 2, 5839, 1211, 3, 2, 2, 2, 5840, 5841, 7, 37, 2, 2, 5841, 1213, 3, 2, 2, 2, 5842, 5843, 7, 49, 2, 2, 5843, 5844, 7, 44, 2, 2, 5844, 5849, 3, 2, 2, 2, 5845, 5848, 5, 1214, 607, 2, 5846, 5848, 11, 2, 2, 2, 5847, 5845, 3, 2, 2, 2, 5847, 5846, 3, 2, 2, 2, 5848, 5851, 3, 2, 2, 2, 5849, 5850, 3, 2, 2, 2, 5849, 5847, 3, 2, 2, 2, 5850, 5852, 3, 2, 2, 2, 5851, 5849, 3, 2, 2, 2, 5852, 5853, 7, 44, 2, 2, 5853, 5854, 7, 49, 2, 2, 5854, 5855, 3, 2, 2, 2, 5855, 5856, 8, 607, 2, 2, 5856, 1215, 3, 2, 2, 2, 5857, 5858, 7, 47, 2, 2, 5858, 5859, 7, 47, 2, 2, 5859, 5863, 3, 2, 2, 2, 5860, 5862, 10, 28, 2, 2, 5861, 5860, 3, 2, 2, 2, 5862, 5865, 3, 2, 2, 2, 5863, 5861, 3, 2, 2, 2, 5863, 5864, 3, 2, 2, 2, 5864, 5866, 3, 2, 2, 2, 5865, 5863, 3, 2, 2, 2, 5866, 5867, 8, 608, 2, 2, 5867, 1217, 3, 2, 2, 2, 5868, 5870, 5, 1220, 610, 2, 5869, 5868, 3, 2, 2, 2, 5870, 5871, 3, 2, 2, 2, 5871, 5869, 3, 2, 2, 2, 5871, 5872, 3, 2, 2, 2, 5872, 5873, 3, 2, 2, 2, 5873, 5874, 5, 1222, 611, 2, 5874, 5891, 3, 2, 2, 2, 5875, 5878, 5, 1220, 610, 2, 5876, 5878, 5, 1224, 612, 2, 5877, 5875, 3, 2, 2, 2, 5877, 5876, 3, 2, 2, 2, 5878, 5881, 3, 2, 2, 2, 5879, 5877, 3, 2, 2, 2, 5879, 5880, 3, 2, 2, 2, 5880, 5882, 3, 2, 2, 2, 5881, 5879, 3, 2, 2, 2, 5882, 5887, 5, 1224, 612, 2, 5883, 5886, 5, 1220, 610, 2, 5884, 5886, 5, 1224, 612, 2, 5885, 5883, 3, 2, 2, 2, 5885, 5884, 3, 2, 2, 2, 5886, 5889, 3, 2, 2, 2, 5887, 5885, 3, 2, 2, 2, 5887, 5888, 3, 2, 2, 2, 5888, 5891, 3, 2, 2, 2, 5889, 5887, 3, 2, 2, 2, 5890, 5869, 3, 2, 2, 2, 5890, 5879, 3, 2, 2, 2, 5891, 1219, 3, 2, 2, 2, 5892, 5898, 9, 29, 2, 2, 5893, 5894, 7, 47, 2, 2, 5894, 5898, 6, 610, 2, 2, 5895, 5896, 7, 49, 2, 2, 5896, 5898, 6, 610, 3, 2, 5897, 5892, 3, 2, 2, 2, 5897, 5893, 3, 2, 2, 2, 5897, 5895, 3, 2, 2, 2, 5898, 1221, 3, 2, 2, 2, 5899, 5900, 9, 30, 2, 2, 5900, 1223, 3, 2, 2, 2, 5901, 5902, 9, 31, 2, 2, 5902, 1225, 3, 2, 2, 2, 5903, 5905, 5, 1228, 614, 2, 5904, 5903, 3, 2, 2, 2, 5905, 5906, 3, 2, 2, 2, 5906, 5904, 3, 2, 2, 2, 5906, 5907, 3, 2, 2, 2, 5907, 1227, 3, 2, 2, 2, 5908, 5909, 4, 50, 59, 2, 5909, 1229, 3, 2, 2, 2, 5910, 5912, 5, 1228, 614, 2, 5911, 5910, 3, 2, 2, 2, 5912, 5913, 3, 2, 2, 2, 5913, 5911, 3, 2, 2, 2, 5913, 5914, 3, 2, 2, 2, 5914, 5915, 3, 2, 2, 2, 5915, 5916, 7, 48, 2, 2, 5916, 5917, 6, 615, 4, 2, 5917, 5957, 3, 2, 2, 2, 5918, 5920, 5, 1228, 614, 2, 5919, 5918, 3, 2, 2, 2, 5920, 5921, 3, 2, 2, 2, 5921, 5919, 3, 2, 2, 2, 5921, 5922, 3, 2, 2, 2, 5922, 5923, 3, 2, 2, 2, 5923, 5925, 7, 48, 2, 2, 5924, 5926, 5, 1228, 614, 2, 5925, 5924, 3, 2, 2, 2, 5926, 5927, 3, 2, 2, 2, 5927, 5925, 3, 2, 2, 2, 5927, 5928, 3, 2, 2, 2, 5928, 5930, 3, 2, 2, 2, 5929, 5931, 5, 1256, 628, 2, 5930, 5929, 3, 2, 2, 2, 5930, 5931, 3, 2, 2, 2, 5931, 5957, 3, 2, 2, 2, 5932, 5934, 5, 1228, 614, 2, 5933, 5932, 3, 2, 2, 2, 5934, 5935, 3, 2, 2, 2, 5935, 5933, 3, 2, 2, 2, 5935, 5936, 3, 2, 2, 2, 5936, 5937, 3, 2, 2, 2, 5937, 5938, 7, 48, 2, 2, 5938, 5939, 5, 1256, 628, 2, 5939, 5957, 3, 2, 2, 2, 5940, 5942, 7, 48, 2, 2, 5941, 5943, 5, 1228, 614, 2, 5942, 5941, 3, 2, 2, 2, 5943, 5944, 3, 2, 2, 2, 5944, 5942, 3, 2, 2, 2, 5944, 5945, 3, 2, 2, 2, 5945, 5947, 3, 2, 2, 2, 5946, 5948, 5, 1256, 628, 2, 5947, 5946, 3, 2, 2, 2, 5947, 5948, 3, 2, 2, 2, 5948, 5957, 3, 2, 2, 2, 5949, 5951, 5, 1228, 614, 2, 5950, 5949, 3, 2, 2, 2, 5951, 5952, 3, 2, 2, 2, 5952, 5950, 3, 2, 2, 2, 5952, 5953, 3, 2, 2, 2, 5953, 5954, 3, 2, 2, 2, 5954, 5955, 5, 1256, 628, 2, 5955, 5957, 3, 2, 2, 2, 5956, 5911, 3, 2, 2, 2, 5956, 5919, 3, 2, 2, 2, 5956, 5933, 3, 2, 2, 2, 5956, 5940, 3, 2, 2, 2, 5956, 5950, 3, 2, 2, 2, 5957, 1231, 3, 2, 2, 2, 5958, 5959, 5, 1196, 598, 2, 5959, 5960, 5, 1226, 613, 2, 5960, 1233, 3, 2, 2, 2, 5961, 5965, 5, 1236, 618, 2, 5962, 5964, 5, 1238, 619, 2, 5963, 5962, 3, 2, 2, 2, 5964, 5967, 3, 2, 2, 2, 5965, 5963, 3, 2, 2, 2, 5965, 5966, 3, 2, 2, 2, 5966, 5968, 3, 2, 2, 2, 5967, 5965, 3, 2, 2, 2, 5968, 5969, 8, 617, 3, 2, 5969, 1235, 3, 2, 2, 2, 5970, 5977, 9, 32, 2, 2, 5971, 5972, 9, 33, 2, 2, 5972, 5977, 6, 618, 5, 2, 5973, 5974, 9, 34, 2, 2, 5974, 5975, 9, 35, 2, 2, 5975, 5977, 6, 618, 6, 2, 5976, 5970, 3, 2, 2, 2, 5976, 5971, 3, 2, 2, 2, 5976, 5973, 3, 2, 2, 2, 5977, 1237, 3, 2, 2, 2, 5978, 5981, 5, 1240, 620, 2, 5979, 5981, 7, 38, 2, 2, 5980, 5978, 3, 2, 2, 2, 5980, 5979, 3, 2, 2, 2, 5981, 1239, 3, 2, 2, 2, 5982, 5985, 5, 1236, 618, 2, 5983, 5985, 9, 36, 2, 2, 5984, 5982, 3, 2, 2, 2, 5984, 5983, 3, 2, 2, 2, 5985, 1241, 3, 2, 2, 2, 5986, 5987, 5, 1244, 622, 2, 5987, 5988, 7, 36, 2, 2, 5988, 5989, 8, 621, 4, 2, 5989, 1243, 3, 2, 2, 2, 5990, 5996, 7, 36, 2, 2, 5991, 5992, 7, 36, 2, 2, 5992, 5995, 7, 36, 2, 2, 5993, 5995, 10, 37, 2, 2, 5994, 5991, 3, 2, 2, 2, 5994, 5993, 3, 2, 2, 2, 5995, 5998, 3, 2, 2, 2, 5996, 5994, 3, 2, 2, 2, 5996, 5997, 3, 2, 2, 2, 5997, 1245, 3, 2, 2, 2, 5998, 5996, 3, 2, 2, 2, 5999, 6000, 9, 38, 2, 2, 6000, 1247, 3, 2, 2, 2, 6001, 6002, 4, 130, 161, 2, 6002, 1249, 3, 2, 2, 2, 6003, 6005, 9, 39, 2, 2, 6004, 6003, 3, 2, 2, 2, 6004, 6005, 3, 2, 2, 2, 6005, 6006, 3, 2, 2, 2, 6006, 6012, 5, 1252, 626, 2, 6007, 6008, 5, 1254, 627, 2, 6008, 6009, 5, 1252, 626, 2, 6009, 6011, 3, 2, 2, 2, 6010, 6007, 3, 2, 2, 2, 6011, 6014, 3, 2, 2, 2, 6012, 6010, 3, 2, 2, 2, 6012, 6013, 3, 2, 2, 2, 6013, 1251, 3, 2, 2, 2, 6014, 6012, 3, 2, 2, 2, 6015, 6021, 5, 1192, 596, 2, 6016, 6020, 10, 40, 2, 2, 6017, 6018, 7, 41, 2, 2, 6018, 6020, 7, 41, 2, 2, 6019, 6016, 3, 2, 2, 2, 6019, 6017, 3, 2, 2, 2, 6020, 6023, 3, 2, 2, 2, 6021, 6019, 3, 2, 2, 2, 6021, 6022, 3, 2, 2, 2, 6022, 6024, 3, 2, 2, 2, 6023, 6021, 3, 2, 2, 2, 6024, 6025, 5, 1192, 596, 2, 6025, 1253, 3, 2, 2, 2, 6026, 6031, 5, 1262, 631, 2, 6027, 6031, 5, 1268, 634, 2, 6028, 6031, 5, 1264, 632, 2, 6029, 6031, 5, 1216, 608, 2, 6030, 6026, 3, 2, 2, 2, 6030, 6027, 3, 2, 2, 2, 6030, 6028, 3, 2, 2, 2, 6030, 6029, 3, 2, 2, 2, 6031, 6034, 3, 2, 2, 2, 6032, 6030, 3, 2, 2, 2, 6032, 6033, 3, 2, 2, 2, 6033, 6035, 3, 2, 2, 2, 6034, 6032, 3, 2, 2, 2, 6035, 6037, 5, 1266, 633, 2, 6036, 6032, 3, 2, 2, 2, 6037, 6038, 3, 2, 2, 2, 6038, 6036, 3, 2, 2, 2, 6038, 6039, 3, 2, 2, 2, 6039, 6045, 3, 2, 2, 2, 6040, 6044, 5, 1262, 631, 2, 6041, 6044, 5, 1268, 634, 2, 6042, 6044, 5, 1264, 632, 2, 6043, 6040, 3, 2, 2, 2, 6043, 6041, 3, 2, 2, 2, 6043, 6042, 3, 2, 2, 2, 6044, 6047, 3, 2, 2, 2, 6045, 6043, 3, 2, 2, 2, 6045, 6046, 3, 2, 2, 2, 6046, 1255, 3, 2, 2, 2, 6047, 6045, 3, 2, 2, 2, 6048, 6050, 9, 10, 2, 2, 6049, 6051, 9, 41, 2, 2, 6050, 6049, 3, 2, 2, 2, 6050, 6051, 3, 2, 2, 2, 6051, 6053, 3, 2, 2, 2, 6052, 6054, 5, 1228, 614, 2, 6053, 6052, 3, 2, 2, 2, 6054, 6055, 3, 2, 2, 2, 6055, 6053, 3, 2, 2, 2, 6055, 6056, 3, 2, 2, 2, 6056, 1257, 3, 2, 2, 2, 6057, 6059, 7, 38, 2, 2, 6058, 6060, 5, 1260, 630, 2, 6059, 6058, 3, 2, 2, 2, 6059, 6060, 3, 2, 2, 2, 6060, 6061, 3, 2, 2, 2, 6061, 6062, 7, 38, 2, 2, 6062, 6063, 8, 629, 5, 2, 6063, 6064, 3, 2, 2, 2, 6064, 6065, 8, 629, 6, 2, 6065, 1259, 3, 2, 2, 2, 6066, 6070, 5, 1236, 618, 2, 6067, 6069, 5, 1240, 620, 2, 6068, 6067, 3, 2, 2, 2, 6069, 6072, 3, 2, 2, 2, 6070, 6068, 3, 2, 2, 2, 6070, 6071, 3, 2, 2, 2, 6071, 1261, 3, 2, 2, 2, 6072, 6070, 3, 2, 2, 2, 6073, 6074, 7, 34, 2, 2, 6074, 6075, 3, 2, 2, 2, 6075, 6076, 8, 631, 2, 2, 6076, 1263, 3, 2, 2, 2, 6077, 6080, 5, 1246, 623, 2, 6078, 6080, 5, 1248, 624, 2, 6079, 6077, 3, 2, 2, 2, 6079, 6078, 3, 2, 2, 2, 6080, 6081, 3, 2, 2, 2, 6081, 6079, 3, 2, 2, 2, 6081, 6082, 3, 2, 2, 2, 6082, 6083, 3, 2, 2, 2, 6083, 6084, 8, 632, 2, 2, 6084, 1265, 3, 2, 2, 2, 6085, 6091, 7, 15, 2, 2, 6086, 6088, 7, 15, 2, 2, 6087, 6086, 3, 2, 2, 2, 6087, 6088, 3, 2, 2, 2, 6088, 6089, 3, 2, 2, 2, 6089, 6091, 7, 12, 2, 2, 6090, 6085, 3, 2, 2, 2, 6090, 6087, 3, 2, 2, 2, 6091, 6092, 3, 2, 2, 2, 6092, 6093, 8, 633, 2, 2, 6093, 1267, 3, 2, 2, 2, 6094, 6095, 7, 11, 2, 2, 6095, 6096, 3, 2, 2, 2, 6096, 6097, 8, 634, 2, 2, 6097, 1269, 3, 2, 2, 2, 6098, 6099, 7, 65281, 2, 2, 6099, 1271, 3, 2, 2, 2, 6100, 6101, 11, 2, 2, 2, 6101, 1273, 3, 2, 2, 2, 6102, 6104, 10, 42, 2, 2, 6103, 6102, 3, 2, 2, 2, 6104, 6105, 3, 2, 2, 2, 6105, 6103, 3, 2, 2, 2, 6105, 6106, 3, 2, 2, 2, 6106, 6115, 3, 2, 2, 2, 6107, 6111, 7, 38, 2, 2, 6108, 6110, 10, 42, 2, 2, 6109, 6108, 3, 2, 2, 2, 6110, 6113, 3, 2, 2, 2, 6111, 6109, 3, 2, 2, 2, 6111, 6112, 3, 2, 2, 2, 6112, 6115, 3, 2, 2, 2, 6113, 6111, 3, 2, 2, 2, 6114, 6103, 3, 2, 2, 2, 6114, 6107, 3, 2, 2, 2, 6115, 1275, 3, 2, 2, 2, 6116, 6118, 7, 38, 2, 2, 6117, 6119, 5, 1260, 630, 2, 6118, 6117, 3, 2, 2, 2, 6118, 6119, 3, 2, 2, 2, 6119, 6120, 3, 2, 2, 2, 6120, 6121, 7, 38, 2, 2, 6121, 6122, 6, 638, 7, 2, 6122, 6123, 8, 638, 7, 2, 6123, 6124, 3, 2, 2, 2, 6124, 6125, 8, 638, 8, 2, 6125, 1277, 3, 2, 2, 2, 52, 2, 3, 5785, 5847, 5849, 5863, 5871, 5877, 5879, 5885, 5887, 5890, 5897, 5906, 5913, 5921, 5927, 5930, 5935, 5944, 5947, 5952, 5956, 5965, 5976, 5980, 5984, 5994, 5996, 6004, 6012, 6019, 6021, 6030, 6032, 6038, 6043, 6045, 6050, 6055, 6059, 6070, 6079, 6081, 6087, 6090, 6105, 6111, 6114, 6118, 9, 2, 3, 2, 3, 617, 2, 3, 621, 3, 3, 629, 4, 7, 3, 2, 3, 638, 5, 6, 2, 2] diff --git a/sql_to_code/parsers/generated/PLpgSQLLexer.py b/sql_to_code/parsers/generated/PLpgSQLLexer.py new file mode 100644 index 0000000..71d4796 --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLLexer.py @@ -0,0 +1,4133 @@ +# Generated from PLpgSQLLexer.g4 by ANTLR 4.9 +from antlr4 import * +from io import StringIO +from typing.io import TextIO +import sys + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0270") + buf.write("\u17ee\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6") + buf.write("\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r") + buf.write("\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22") + buf.write("\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30") + buf.write("\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35") + buf.write("\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4") + buf.write("%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t") + buf.write("-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63") + buf.write("\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4") + buf.write(":\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4") + buf.write("C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4") + buf.write("L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4") + buf.write("U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t") + buf.write("]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\t") + buf.write("f\4g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\t") + buf.write("o\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\t") + buf.write("x\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080") + buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083") + buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087") + buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a") + buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e") + buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091") + buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095") + buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098") + buf.write("\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c") + buf.write("\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f") + buf.write("\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3") + buf.write("\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6") + buf.write("\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa") + buf.write("\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad") + buf.write("\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1") + buf.write("\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4") + buf.write("\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8") + buf.write("\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb") + buf.write("\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf") + buf.write("\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2") + buf.write("\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6") + buf.write("\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9") + buf.write("\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd") + buf.write("\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0") + buf.write("\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4") + buf.write("\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7") + buf.write("\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db") + buf.write("\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de") + buf.write("\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2") + buf.write("\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5") + buf.write("\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9") + buf.write("\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec") + buf.write("\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0") + buf.write("\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3") + buf.write("\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7") + buf.write("\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa") + buf.write("\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe") + buf.write("\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101") + buf.write("\4\u0102\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104\4\u0105") + buf.write("\t\u0105\4\u0106\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108") + buf.write("\4\u0109\t\u0109\4\u010a\t\u010a\4\u010b\t\u010b\4\u010c") + buf.write("\t\u010c\4\u010d\t\u010d\4\u010e\t\u010e\4\u010f\t\u010f") + buf.write("\4\u0110\t\u0110\4\u0111\t\u0111\4\u0112\t\u0112\4\u0113") + buf.write("\t\u0113\4\u0114\t\u0114\4\u0115\t\u0115\4\u0116\t\u0116") + buf.write("\4\u0117\t\u0117\4\u0118\t\u0118\4\u0119\t\u0119\4\u011a") + buf.write("\t\u011a\4\u011b\t\u011b\4\u011c\t\u011c\4\u011d\t\u011d") + buf.write("\4\u011e\t\u011e\4\u011f\t\u011f\4\u0120\t\u0120\4\u0121") + buf.write("\t\u0121\4\u0122\t\u0122\4\u0123\t\u0123\4\u0124\t\u0124") + buf.write("\4\u0125\t\u0125\4\u0126\t\u0126\4\u0127\t\u0127\4\u0128") + buf.write("\t\u0128\4\u0129\t\u0129\4\u012a\t\u012a\4\u012b\t\u012b") + buf.write("\4\u012c\t\u012c\4\u012d\t\u012d\4\u012e\t\u012e\4\u012f") + buf.write("\t\u012f\4\u0130\t\u0130\4\u0131\t\u0131\4\u0132\t\u0132") + buf.write("\4\u0133\t\u0133\4\u0134\t\u0134\4\u0135\t\u0135\4\u0136") + buf.write("\t\u0136\4\u0137\t\u0137\4\u0138\t\u0138\4\u0139\t\u0139") + buf.write("\4\u013a\t\u013a\4\u013b\t\u013b\4\u013c\t\u013c\4\u013d") + buf.write("\t\u013d\4\u013e\t\u013e\4\u013f\t\u013f\4\u0140\t\u0140") + buf.write("\4\u0141\t\u0141\4\u0142\t\u0142\4\u0143\t\u0143\4\u0144") + buf.write("\t\u0144\4\u0145\t\u0145\4\u0146\t\u0146\4\u0147\t\u0147") + buf.write("\4\u0148\t\u0148\4\u0149\t\u0149\4\u014a\t\u014a\4\u014b") + buf.write("\t\u014b\4\u014c\t\u014c\4\u014d\t\u014d\4\u014e\t\u014e") + buf.write("\4\u014f\t\u014f\4\u0150\t\u0150\4\u0151\t\u0151\4\u0152") + buf.write("\t\u0152\4\u0153\t\u0153\4\u0154\t\u0154\4\u0155\t\u0155") + buf.write("\4\u0156\t\u0156\4\u0157\t\u0157\4\u0158\t\u0158\4\u0159") + buf.write("\t\u0159\4\u015a\t\u015a\4\u015b\t\u015b\4\u015c\t\u015c") + buf.write("\4\u015d\t\u015d\4\u015e\t\u015e\4\u015f\t\u015f\4\u0160") + buf.write("\t\u0160\4\u0161\t\u0161\4\u0162\t\u0162\4\u0163\t\u0163") + buf.write("\4\u0164\t\u0164\4\u0165\t\u0165\4\u0166\t\u0166\4\u0167") + buf.write("\t\u0167\4\u0168\t\u0168\4\u0169\t\u0169\4\u016a\t\u016a") + buf.write("\4\u016b\t\u016b\4\u016c\t\u016c\4\u016d\t\u016d\4\u016e") + buf.write("\t\u016e\4\u016f\t\u016f\4\u0170\t\u0170\4\u0171\t\u0171") + buf.write("\4\u0172\t\u0172\4\u0173\t\u0173\4\u0174\t\u0174\4\u0175") + buf.write("\t\u0175\4\u0176\t\u0176\4\u0177\t\u0177\4\u0178\t\u0178") + buf.write("\4\u0179\t\u0179\4\u017a\t\u017a\4\u017b\t\u017b\4\u017c") + buf.write("\t\u017c\4\u017d\t\u017d\4\u017e\t\u017e\4\u017f\t\u017f") + buf.write("\4\u0180\t\u0180\4\u0181\t\u0181\4\u0182\t\u0182\4\u0183") + buf.write("\t\u0183\4\u0184\t\u0184\4\u0185\t\u0185\4\u0186\t\u0186") + buf.write("\4\u0187\t\u0187\4\u0188\t\u0188\4\u0189\t\u0189\4\u018a") + buf.write("\t\u018a\4\u018b\t\u018b\4\u018c\t\u018c\4\u018d\t\u018d") + buf.write("\4\u018e\t\u018e\4\u018f\t\u018f\4\u0190\t\u0190\4\u0191") + buf.write("\t\u0191\4\u0192\t\u0192\4\u0193\t\u0193\4\u0194\t\u0194") + buf.write("\4\u0195\t\u0195\4\u0196\t\u0196\4\u0197\t\u0197\4\u0198") + buf.write("\t\u0198\4\u0199\t\u0199\4\u019a\t\u019a\4\u019b\t\u019b") + buf.write("\4\u019c\t\u019c\4\u019d\t\u019d\4\u019e\t\u019e\4\u019f") + buf.write("\t\u019f\4\u01a0\t\u01a0\4\u01a1\t\u01a1\4\u01a2\t\u01a2") + buf.write("\4\u01a3\t\u01a3\4\u01a4\t\u01a4\4\u01a5\t\u01a5\4\u01a6") + buf.write("\t\u01a6\4\u01a7\t\u01a7\4\u01a8\t\u01a8\4\u01a9\t\u01a9") + buf.write("\4\u01aa\t\u01aa\4\u01ab\t\u01ab\4\u01ac\t\u01ac\4\u01ad") + buf.write("\t\u01ad\4\u01ae\t\u01ae\4\u01af\t\u01af\4\u01b0\t\u01b0") + buf.write("\4\u01b1\t\u01b1\4\u01b2\t\u01b2\4\u01b3\t\u01b3\4\u01b4") + buf.write("\t\u01b4\4\u01b5\t\u01b5\4\u01b6\t\u01b6\4\u01b7\t\u01b7") + buf.write("\4\u01b8\t\u01b8\4\u01b9\t\u01b9\4\u01ba\t\u01ba\4\u01bb") + buf.write("\t\u01bb\4\u01bc\t\u01bc\4\u01bd\t\u01bd\4\u01be\t\u01be") + buf.write("\4\u01bf\t\u01bf\4\u01c0\t\u01c0\4\u01c1\t\u01c1\4\u01c2") + buf.write("\t\u01c2\4\u01c3\t\u01c3\4\u01c4\t\u01c4\4\u01c5\t\u01c5") + buf.write("\4\u01c6\t\u01c6\4\u01c7\t\u01c7\4\u01c8\t\u01c8\4\u01c9") + buf.write("\t\u01c9\4\u01ca\t\u01ca\4\u01cb\t\u01cb\4\u01cc\t\u01cc") + buf.write("\4\u01cd\t\u01cd\4\u01ce\t\u01ce\4\u01cf\t\u01cf\4\u01d0") + buf.write("\t\u01d0\4\u01d1\t\u01d1\4\u01d2\t\u01d2\4\u01d3\t\u01d3") + buf.write("\4\u01d4\t\u01d4\4\u01d5\t\u01d5\4\u01d6\t\u01d6\4\u01d7") + buf.write("\t\u01d7\4\u01d8\t\u01d8\4\u01d9\t\u01d9\4\u01da\t\u01da") + buf.write("\4\u01db\t\u01db\4\u01dc\t\u01dc\4\u01dd\t\u01dd\4\u01de") + buf.write("\t\u01de\4\u01df\t\u01df\4\u01e0\t\u01e0\4\u01e1\t\u01e1") + buf.write("\4\u01e2\t\u01e2\4\u01e3\t\u01e3\4\u01e4\t\u01e4\4\u01e5") + buf.write("\t\u01e5\4\u01e6\t\u01e6\4\u01e7\t\u01e7\4\u01e8\t\u01e8") + buf.write("\4\u01e9\t\u01e9\4\u01ea\t\u01ea\4\u01eb\t\u01eb\4\u01ec") + buf.write("\t\u01ec\4\u01ed\t\u01ed\4\u01ee\t\u01ee\4\u01ef\t\u01ef") + buf.write("\4\u01f0\t\u01f0\4\u01f1\t\u01f1\4\u01f2\t\u01f2\4\u01f3") + buf.write("\t\u01f3\4\u01f4\t\u01f4\4\u01f5\t\u01f5\4\u01f6\t\u01f6") + buf.write("\4\u01f7\t\u01f7\4\u01f8\t\u01f8\4\u01f9\t\u01f9\4\u01fa") + buf.write("\t\u01fa\4\u01fb\t\u01fb\4\u01fc\t\u01fc\4\u01fd\t\u01fd") + buf.write("\4\u01fe\t\u01fe\4\u01ff\t\u01ff\4\u0200\t\u0200\4\u0201") + buf.write("\t\u0201\4\u0202\t\u0202\4\u0203\t\u0203\4\u0204\t\u0204") + buf.write("\4\u0205\t\u0205\4\u0206\t\u0206\4\u0207\t\u0207\4\u0208") + buf.write("\t\u0208\4\u0209\t\u0209\4\u020a\t\u020a\4\u020b\t\u020b") + buf.write("\4\u020c\t\u020c\4\u020d\t\u020d\4\u020e\t\u020e\4\u020f") + buf.write("\t\u020f\4\u0210\t\u0210\4\u0211\t\u0211\4\u0212\t\u0212") + buf.write("\4\u0213\t\u0213\4\u0214\t\u0214\4\u0215\t\u0215\4\u0216") + buf.write("\t\u0216\4\u0217\t\u0217\4\u0218\t\u0218\4\u0219\t\u0219") + buf.write("\4\u021a\t\u021a\4\u021b\t\u021b\4\u021c\t\u021c\4\u021d") + buf.write("\t\u021d\4\u021e\t\u021e\4\u021f\t\u021f\4\u0220\t\u0220") + buf.write("\4\u0221\t\u0221\4\u0222\t\u0222\4\u0223\t\u0223\4\u0224") + buf.write("\t\u0224\4\u0225\t\u0225\4\u0226\t\u0226\4\u0227\t\u0227") + buf.write("\4\u0228\t\u0228\4\u0229\t\u0229\4\u022a\t\u022a\4\u022b") + buf.write("\t\u022b\4\u022c\t\u022c\4\u022d\t\u022d\4\u022e\t\u022e") + buf.write("\4\u022f\t\u022f\4\u0230\t\u0230\4\u0231\t\u0231\4\u0232") + buf.write("\t\u0232\4\u0233\t\u0233\4\u0234\t\u0234\4\u0235\t\u0235") + buf.write("\4\u0236\t\u0236\4\u0237\t\u0237\4\u0238\t\u0238\4\u0239") + buf.write("\t\u0239\4\u023a\t\u023a\4\u023b\t\u023b\4\u023c\t\u023c") + buf.write("\4\u023d\t\u023d\4\u023e\t\u023e\4\u023f\t\u023f\4\u0240") + buf.write("\t\u0240\4\u0241\t\u0241\4\u0242\t\u0242\4\u0243\t\u0243") + buf.write("\4\u0244\t\u0244\4\u0245\t\u0245\4\u0246\t\u0246\4\u0247") + buf.write("\t\u0247\4\u0248\t\u0248\4\u0249\t\u0249\4\u024a\t\u024a") + buf.write("\4\u024b\t\u024b\4\u024c\t\u024c\4\u024d\t\u024d\4\u024e") + buf.write("\t\u024e\4\u024f\t\u024f\4\u0250\t\u0250\4\u0251\t\u0251") + buf.write("\4\u0252\t\u0252\4\u0253\t\u0253\4\u0254\t\u0254\4\u0255") + buf.write("\t\u0255\4\u0256\t\u0256\4\u0257\t\u0257\4\u0258\t\u0258") + buf.write("\4\u0259\t\u0259\4\u025a\t\u025a\4\u025b\t\u025b\4\u025c") + buf.write("\t\u025c\4\u025d\t\u025d\4\u025e\t\u025e\4\u025f\t\u025f") + buf.write("\4\u0260\t\u0260\4\u0261\t\u0261\4\u0262\t\u0262\4\u0263") + buf.write("\t\u0263\4\u0264\t\u0264\4\u0265\t\u0265\4\u0266\t\u0266") + buf.write("\4\u0267\t\u0267\4\u0268\t\u0268\4\u0269\t\u0269\4\u026a") + buf.write("\t\u026a\4\u026b\t\u026b\4\u026c\t\u026c\4\u026d\t\u026d") + buf.write("\4\u026e\t\u026e\4\u026f\t\u026f\4\u0270\t\u0270\4\u0271") + buf.write("\t\u0271\4\u0272\t\u0272\4\u0273\t\u0273\4\u0274\t\u0274") + buf.write("\4\u0275\t\u0275\4\u0276\t\u0276\4\u0277\t\u0277\4\u0278") + buf.write("\t\u0278\4\u0279\t\u0279\4\u027a\t\u027a\4\u027b\t\u027b") + buf.write("\4\u027c\t\u027c\4\u027d\t\u027d\4\u027e\t\u027e\3\2\3") + buf.write("\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3") + buf.write("\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3") + buf.write("\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b") + buf.write("\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3") + buf.write("\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3") + buf.write("\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r") + buf.write("\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16") + buf.write("\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20") + buf.write("\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21") + buf.write("\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23") + buf.write("\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24") + buf.write("\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27") + buf.write("\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31") + buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32") + buf.write("\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33") + buf.write("\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35") + buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35") + buf.write("\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36") + buf.write("\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3") + buf.write(" \3 \3!\3!\3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3") + buf.write("\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3") + buf.write("$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3") + buf.write("&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'") + buf.write("\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3") + buf.write(")\3)\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3") + buf.write("+\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3") + buf.write("-\3-\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3") + buf.write("\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62") + buf.write("\3\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63") + buf.write("\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65") + buf.write("\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66") + buf.write("\3\67\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\38\38") + buf.write("\39\39\39\39\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3") + buf.write(";\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3<\3<\3<\3=\3") + buf.write("=\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3?\3?\3") + buf.write("?\3?\3?\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3@\3@\3@\3A\3") + buf.write("A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3C\3") + buf.write("C\3C\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3") + buf.write("E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3") + buf.write("G\3G\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\3") + buf.write("J\3K\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3L\3") + buf.write("L\3L\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3") + buf.write("O\3O\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3") + buf.write("Q\3Q\3R\3R\3R\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3") + buf.write("S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3U\3") + buf.write("U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3") + buf.write("X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3") + buf.write("Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3") + buf.write("\\\3\\\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3") + buf.write("^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3") + buf.write("`\3`\3`\3`\3a\3a\3a\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3") + buf.write("b\3c\3c\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3") + buf.write("e\3e\3e\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3g\3g\3g\3g\3h\3") + buf.write("h\3h\3i\3i\3i\3i\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3") + buf.write("j\3j\3j\3j\3k\3k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3") + buf.write("l\3l\3m\3m\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3") + buf.write("n\3n\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3") + buf.write("q\3q\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3r\3r\3r\3r\3s\3s\3") + buf.write("s\3s\3s\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3u\3u\3u\3u\3") + buf.write("u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3") + buf.write("w\3w\3w\3x\3x\3x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3") + buf.write("y\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3|\3|\3|\3") + buf.write("|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3~\3~\3~\3~\3~\3") + buf.write("\177\3\177\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3") + buf.write("\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080") + buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082") + buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084") + buf.write("\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085") + buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086") + buf.write("\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0087") + buf.write("\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0088") + buf.write("\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089") + buf.write("\3\u0089\3\u0089\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a") + buf.write("\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b") + buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b") + buf.write("\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c") + buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d") + buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f") + buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090") + buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091") + buf.write("\3\u0091\3\u0091\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092") + buf.write("\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094") + buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0095\3\u0095") + buf.write("\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096") + buf.write("\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098") + buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099") + buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\3\u009c") + buf.write("\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d\3\u009d\3\u009e") + buf.write("\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f\3\u009f\3\u009f") + buf.write("\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1") + buf.write("\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1") + buf.write("\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2") + buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3") + buf.write("\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4") + buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5") + buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6") + buf.write("\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7") + buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7") + buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a9") + buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa") + buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa") + buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab") + buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac") + buf.write("\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad") + buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae") + buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af") + buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af") + buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1") + buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2") + buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2") + buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3") + buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4") + buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5") + buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5") + buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b7") + buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7") + buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9") + buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba") + buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba") + buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb") + buf.write("\3\u00bb\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc") + buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bd") + buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be") + buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf") + buf.write("\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0") + buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c1") + buf.write("\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2\3\u00c2") + buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2") + buf.write("\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4") + buf.write("\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4") + buf.write("\3\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5") + buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6") + buf.write("\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c7\3\u00c7") + buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7") + buf.write("\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8") + buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9") + buf.write("\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca") + buf.write("\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00cb\3\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cc") + buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc") + buf.write("\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce") + buf.write("\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce") + buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf") + buf.write("\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0") + buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1\3\u00d1\3\u00d1") + buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2") + buf.write("\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3") + buf.write("\3\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4\3\u00d4") + buf.write("\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5\3\u00d5") + buf.write("\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6") + buf.write("\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d7") + buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8") + buf.write("\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9") + buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da") + buf.write("\3\u00da\3\u00da\3\u00da\3\u00da\3\u00da\3\u00db\3\u00db") + buf.write("\3\u00db\3\u00db\3\u00db\3\u00db\3\u00db\3\u00db\3\u00dc") + buf.write("\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dd") + buf.write("\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de") + buf.write("\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00df") + buf.write("\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df") + buf.write("\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0") + buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\3\u00e1") + buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2") + buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2") + buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e3\3\u00e3") + buf.write("\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e4\3\u00e4") + buf.write("\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e5") + buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e6") + buf.write("\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7") + buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e9\3\u00e9") + buf.write("\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea\3\u00ea") + buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb\3\u00eb") + buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec") + buf.write("\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed") + buf.write("\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee") + buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ef") + buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0") + buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0") + buf.write("\3\u00f0\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1") + buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2\3\u00f2") + buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f3") + buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4") + buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5") + buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6") + buf.write("\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f7\3\u00f7") + buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8") + buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8") + buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9\3\u00f9") + buf.write("\3\u00f9\3\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa") + buf.write("\3\u00fa\3\u00fa\3\u00fa\3\u00fb\3\u00fb\3\u00fb\3\u00fb") + buf.write("\3\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc") + buf.write("\3\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd\3\u00fd\3\u00fd") + buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd") + buf.write("\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00ff\3\u00ff") + buf.write("\3\u00ff\3\u00ff\3\u00ff\3\u00ff\3\u00ff\3\u00ff\3\u00ff") + buf.write("\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100") + buf.write("\3\u0100\3\u0100\3\u0100\3\u0101\3\u0101\3\u0101\3\u0101") + buf.write("\3\u0101\3\u0102\3\u0102\3\u0102\3\u0102\3\u0102\3\u0103") + buf.write("\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103") + buf.write("\3\u0103\3\u0103\3\u0103\3\u0103\3\u0104\3\u0104\3\u0104") + buf.write("\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104\3\u0104") + buf.write("\3\u0105\3\u0105\3\u0105\3\u0105\3\u0105\3\u0105\3\u0105") + buf.write("\3\u0105\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106") + buf.write("\3\u0106\3\u0106\3\u0106\3\u0107\3\u0107\3\u0107\3\u0107") + buf.write("\3\u0107\3\u0107\3\u0107\3\u0107\3\u0108\3\u0108\3\u0108") + buf.write("\3\u0108\3\u0108\3\u0109\3\u0109\3\u0109\3\u0109\3\u0109") + buf.write("\3\u0109\3\u010a\3\u010a\3\u010a\3\u010a\3\u010a\3\u010a") + buf.write("\3\u010a\3\u010a\3\u010a\3\u010a\3\u010b\3\u010b\3\u010b") + buf.write("\3\u010b\3\u010b\3\u010b\3\u010b\3\u010b\3\u010b\3\u010b") + buf.write("\3\u010b\3\u010b\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c") + buf.write("\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c\3\u010c") + buf.write("\3\u010d\3\u010d\3\u010d\3\u010d\3\u010d\3\u010d\3\u010d") + buf.write("\3\u010d\3\u010e\3\u010e\3\u010e\3\u010e\3\u010e\3\u010e") + buf.write("\3\u010e\3\u010e\3\u010e\3\u010f\3\u010f\3\u010f\3\u010f") + buf.write("\3\u010f\3\u010f\3\u010f\3\u010f\3\u010f\3\u0110\3\u0110") + buf.write("\3\u0110\3\u0110\3\u0110\3\u0110\3\u0111\3\u0111\3\u0111") + buf.write("\3\u0111\3\u0111\3\u0111\3\u0111\3\u0112\3\u0112\3\u0112") + buf.write("\3\u0112\3\u0112\3\u0112\3\u0112\3\u0113\3\u0113\3\u0113") + buf.write("\3\u0113\3\u0113\3\u0113\3\u0114\3\u0114\3\u0114\3\u0114") + buf.write("\3\u0114\3\u0114\3\u0114\3\u0114\3\u0114\3\u0115\3\u0115") + buf.write("\3\u0115\3\u0115\3\u0115\3\u0115\3\u0115\3\u0115\3\u0115") + buf.write("\3\u0115\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116") + buf.write("\3\u0117\3\u0117\3\u0117\3\u0117\3\u0117\3\u0117\3\u0117") + buf.write("\3\u0117\3\u0118\3\u0118\3\u0118\3\u0118\3\u0118\3\u0118") + buf.write("\3\u0118\3\u0118\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011b") + buf.write("\3\u011b\3\u011b\3\u011b\3\u011b\3\u011b\3\u011b\3\u011b") + buf.write("\3\u011b\3\u011c\3\u011c\3\u011c\3\u011c\3\u011c\3\u011c") + buf.write("\3\u011c\3\u011c\3\u011c\3\u011c\3\u011c\3\u011d\3\u011d") + buf.write("\3\u011d\3\u011d\3\u011d\3\u011d\3\u011d\3\u011e\3\u011e") + buf.write("\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e\3\u011f") + buf.write("\3\u011f\3\u011f\3\u011f\3\u011f\3\u0120\3\u0120\3\u0120") + buf.write("\3\u0120\3\u0120\3\u0120\3\u0120\3\u0120\3\u0121\3\u0121") + buf.write("\3\u0121\3\u0121\3\u0121\3\u0121\3\u0122\3\u0122\3\u0122") + buf.write("\3\u0122\3\u0123\3\u0123\3\u0123\3\u0123\3\u0123\3\u0124") + buf.write("\3\u0124\3\u0124\3\u0124\3\u0125\3\u0125\3\u0125\3\u0125") + buf.write("\3\u0125\3\u0126\3\u0126\3\u0126\3\u0126\3\u0126\3\u0126") + buf.write("\3\u0126\3\u0126\3\u0127\3\u0127\3\u0127\3\u0127\3\u0127") + buf.write("\3\u0127\3\u0127\3\u0128\3\u0128\3\u0128\3\u0128\3\u0129") + buf.write("\3\u0129\3\u0129\3\u0129\3\u0129\3\u0129\3\u0129\3\u0129") + buf.write("\3\u012a\3\u012a\3\u012a\3\u012a\3\u012a\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012d\3\u012d\3\u012d\3\u012d") + buf.write("\3\u012e\3\u012e\3\u012e\3\u012e\3\u012e\3\u012e\3\u012e") + buf.write("\3\u012e\3\u012f\3\u012f\3\u012f\3\u012f\3\u012f\3\u012f") + buf.write("\3\u012f\3\u0130\3\u0130\3\u0130\3\u0130\3\u0130\3\u0130") + buf.write("\3\u0130\3\u0130\3\u0131\3\u0131\3\u0131\3\u0131\3\u0131") + buf.write("\3\u0131\3\u0132\3\u0132\3\u0132\3\u0132\3\u0132\3\u0132") + buf.write("\3\u0132\3\u0132\3\u0132\3\u0133\3\u0133\3\u0133\3\u0133") + buf.write("\3\u0133\3\u0133\3\u0133\3\u0133\3\u0133\3\u0134\3\u0134") + buf.write("\3\u0134\3\u0134\3\u0134\3\u0134\3\u0135\3\u0135\3\u0135") + buf.write("\3\u0135\3\u0136\3\u0136\3\u0136\3\u0136\3\u0136\3\u0136") + buf.write("\3\u0136\3\u0136\3\u0137\3\u0137\3\u0137\3\u0137\3\u0137") + buf.write("\3\u0137\3\u0137\3\u0137\3\u0137\3\u0138\3\u0138\3\u0138") + buf.write("\3\u0138\3\u0138\3\u0138\3\u0139\3\u0139\3\u0139\3\u0139") + buf.write("\3\u0139\3\u0139\3\u0139\3\u0139\3\u0139\3\u013a\3\u013a") + buf.write("\3\u013a\3\u013a\3\u013a\3\u013a\3\u013b\3\u013b\3\u013b") + buf.write("\3\u013b\3\u013b\3\u013c\3\u013c\3\u013c\3\u013c\3\u013c") + buf.write("\3\u013c\3\u013c\3\u013d\3\u013d\3\u013d\3\u013d\3\u013d") + buf.write("\3\u013d\3\u013d\3\u013d\3\u013e\3\u013e\3\u013e\3\u013e") + buf.write("\3\u013f\3\u013f\3\u013f\3\u013f\3\u013f\3\u013f\3\u013f") + buf.write("\3\u013f\3\u0140\3\u0140\3\u0140\3\u0140\3\u0140\3\u0140") + buf.write("\3\u0140\3\u0140\3\u0140\3\u0141\3\u0141\3\u0141\3\u0141") + buf.write("\3\u0141\3\u0141\3\u0141\3\u0141\3\u0141\3\u0141\3\u0142") + buf.write("\3\u0142\3\u0142\3\u0142\3\u0142\3\u0143\3\u0143\3\u0143") + buf.write("\3\u0143\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144") + buf.write("\3\u0145\3\u0145\3\u0145\3\u0145\3\u0145\3\u0145\3\u0145") + buf.write("\3\u0145\3\u0145\3\u0146\3\u0146\3\u0146\3\u0146\3\u0146") + buf.write("\3\u0146\3\u0146\3\u0146\3\u0146\3\u0146\3\u0147\3\u0147") + buf.write("\3\u0147\3\u0147\3\u0147\3\u0148\3\u0148\3\u0148\3\u0148") + buf.write("\3\u0148\3\u0148\3\u0148\3\u0148\3\u0148\3\u0148\3\u0149") + buf.write("\3\u0149\3\u0149\3\u0149\3\u0149\3\u0149\3\u014a\3\u014a") + buf.write("\3\u014a\3\u014a\3\u014a\3\u014b\3\u014b\3\u014b\3\u014b") + buf.write("\3\u014b\3\u014b\3\u014b\3\u014c\3\u014c\3\u014c\3\u014c") + buf.write("\3\u014c\3\u014c\3\u014c\3\u014c\3\u014d\3\u014d\3\u014d") + buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d\3\u014d") + buf.write("\3\u014d\3\u014d\3\u014d\3\u014d\3\u014e\3\u014e\3\u014e") + buf.write("\3\u014e\3\u014e\3\u014e\3\u014e\3\u014e\3\u014e\3\u014e") + buf.write("\3\u014f\3\u014f\3\u014f\3\u014f\3\u014f\3\u014f\3\u014f") + buf.write("\3\u014f\3\u014f\3\u014f\3\u014f\3\u0150\3\u0150\3\u0150") + buf.write("\3\u0150\3\u0150\3\u0150\3\u0150\3\u0150\3\u0150\3\u0150") + buf.write("\3\u0151\3\u0151\3\u0151\3\u0151\3\u0151\3\u0151\3\u0151") + buf.write("\3\u0151\3\u0151\3\u0151\3\u0152\3\u0152\3\u0152\3\u0152") + buf.write("\3\u0152\3\u0152\3\u0152\3\u0152\3\u0152\3\u0152\3\u0152") + buf.write("\3\u0152\3\u0152\3\u0152\3\u0153\3\u0153\3\u0153\3\u0153") + buf.write("\3\u0153\3\u0153\3\u0153\3\u0153\3\u0153\3\u0154\3\u0154") + buf.write("\3\u0154\3\u0154\3\u0154\3\u0154\3\u0155\3\u0155\3\u0155") + buf.write("\3\u0155\3\u0155\3\u0155\3\u0155\3\u0155\3\u0156\3\u0156") + buf.write("\3\u0156\3\u0156\3\u0156\3\u0156\3\u0156\3\u0156\3\u0156") + buf.write("\3\u0156\3\u0156\3\u0156\3\u0156\3\u0157\3\u0157\3\u0157") + buf.write("\3\u0157\3\u0157\3\u0157\3\u0157\3\u0157\3\u0157\3\u0158") + buf.write("\3\u0158\3\u0158\3\u0158\3\u0158\3\u0158\3\u0158\3\u0158") + buf.write("\3\u0158\3\u0158\3\u0158\3\u0158\3\u0158\3\u0158\3\u0159") + buf.write("\3\u0159\3\u0159\3\u0159\3\u0159\3\u0159\3\u0159\3\u015a") + buf.write("\3\u015a\3\u015a\3\u015a\3\u015a\3\u015a\3\u015a\3\u015a") + buf.write("\3\u015a\3\u015a\3\u015b\3\u015b\3\u015b\3\u015b\3\u015b") + buf.write("\3\u015b\3\u015b\3\u015b\3\u015b\3\u015b\3\u015b\3\u015b") + buf.write("\3\u015b\3\u015c\3\u015c\3\u015c\3\u015c\3\u015c\3\u015c") + buf.write("\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d") + buf.write("\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d\3\u015d") + buf.write("\3\u015d\3\u015e\3\u015e\3\u015e\3\u015e\3\u015e\3\u015e") + buf.write("\3\u015e\3\u015f\3\u015f\3\u015f\3\u015f\3\u015f\3\u0160") + buf.write("\3\u0160\3\u0160\3\u0160\3\u0160\3\u0160\3\u0161\3\u0161") + buf.write("\3\u0161\3\u0161\3\u0161\3\u0161\3\u0162\3\u0162\3\u0162") + buf.write("\3\u0163\3\u0163\3\u0163\3\u0163\3\u0163\3\u0163\3\u0163") + buf.write("\3\u0164\3\u0164\3\u0164\3\u0164\3\u0164\3\u0165\3\u0165") + buf.write("\3\u0165\3\u0165\3\u0165\3\u0166\3\u0166\3\u0166\3\u0166") + buf.write("\3\u0166\3\u0167\3\u0167\3\u0167\3\u0167\3\u0167\3\u0167") + buf.write("\3\u0167\3\u0167\3\u0168\3\u0168\3\u0168\3\u0168\3\u0168") + buf.write("\3\u0168\3\u0168\3\u0168\3\u0169\3\u0169\3\u0169\3\u0169") + buf.write("\3\u0169\3\u0169\3\u016a\3\u016a\3\u016a\3\u016a\3\u016a") + buf.write("\3\u016a\3\u016a\3\u016a\3\u016a\3\u016b\3\u016b\3\u016b") + buf.write("\3\u016b\3\u016b\3\u016b\3\u016c\3\u016c\3\u016c\3\u016c") + buf.write("\3\u016c\3\u016c\3\u016c\3\u016c\3\u016d\3\u016d\3\u016d") + buf.write("\3\u016d\3\u016d\3\u016d\3\u016d\3\u016d\3\u016d\3\u016d") + buf.write("\3\u016d\3\u016d\3\u016e\3\u016e\3\u016e\3\u016e\3\u016e") + buf.write("\3\u016e\3\u016e\3\u016e\3\u016f\3\u016f\3\u016f\3\u016f") + buf.write("\3\u0170\3\u0170\3\u0170\3\u0170\3\u0170\3\u0170\3\u0170") + buf.write("\3\u0170\3\u0171\3\u0171\3\u0171\3\u0171\3\u0171\3\u0171") + buf.write("\3\u0171\3\u0171\3\u0172\3\u0172\3\u0172\3\u0172\3\u0173") + buf.write("\3\u0173\3\u0173\3\u0173\3\u0174\3\u0174\3\u0174\3\u0174") + buf.write("\3\u0174\3\u0174\3\u0175\3\u0175\3\u0175\3\u0176\3\u0176") + buf.write("\3\u0176\3\u0176\3\u0177\3\u0177\3\u0177\3\u0177\3\u0177") + buf.write("\3\u0177\3\u0177\3\u0177\3\u0177\3\u0177\3\u0177\3\u0178") + buf.write("\3\u0178\3\u0178\3\u0178\3\u0178\3\u0179\3\u0179\3\u0179") + buf.write("\3\u0179\3\u0179\3\u017a\3\u017a\3\u017a\3\u017a\3\u017a") + buf.write("\3\u017b\3\u017b\3\u017b\3\u017b\3\u017b\3\u017b\3\u017c") + buf.write("\3\u017c\3\u017c\3\u017c\3\u017c\3\u017c\3\u017c\3\u017c") + buf.write("\3\u017d\3\u017d\3\u017d\3\u017d\3\u017d\3\u017d\3\u017d") + buf.write("\3\u017e\3\u017e\3\u017e\3\u017e\3\u017e\3\u017e\3\u017e") + buf.write("\3\u017e\3\u017e\3\u017e\3\u017e\3\u017f\3\u017f\3\u017f") + buf.write("\3\u017f\3\u017f\3\u017f\3\u017f\3\u0180\3\u0180\3\u0180") + buf.write("\3\u0180\3\u0180\3\u0180\3\u0180\3\u0180\3\u0180\3\u0180") + buf.write("\3\u0180\3\u0180\3\u0180\3\u0180\3\u0180\3\u0180\3\u0181") + buf.write("\3\u0181\3\u0181\3\u0181\3\u0181\3\u0181\3\u0181\3\u0181") + buf.write("\3\u0181\3\u0181\3\u0181\3\u0181\3\u0181\3\u0182\3\u0182") + buf.write("\3\u0182\3\u0182\3\u0182\3\u0182\3\u0182\3\u0182\3\u0182") + buf.write("\3\u0182\3\u0182\3\u0182\3\u0182\3\u0183\3\u0183\3\u0183") + buf.write("\3\u0183\3\u0183\3\u0183\3\u0183\3\u0183\3\u0183\3\u0183") + buf.write("\3\u0183\3\u0183\3\u0183\3\u0184\3\u0184\3\u0184\3\u0184") + buf.write("\3\u0184\3\u0184\3\u0184\3\u0184\3\u0184\3\u0184\3\u0184") + buf.write("\3\u0184\3\u0184\3\u0184\3\u0184\3\u0184\3\u0184\3\u0184") + buf.write("\3\u0185\3\u0185\3\u0185\3\u0185\3\u0185\3\u0185\3\u0185") + buf.write("\3\u0185\3\u0185\3\u0185\3\u0185\3\u0185\3\u0185\3\u0186") + buf.write("\3\u0186\3\u0186\3\u0186\3\u0186\3\u0186\3\u0186\3\u0186") + buf.write("\3\u0187\3\u0187\3\u0187\3\u0187\3\u0187\3\u0187\3\u0187") + buf.write("\3\u0187\3\u0187\3\u0187\3\u0187\3\u0188\3\u0188\3\u0188") + buf.write("\3\u0188\3\u0188\3\u0189\3\u0189\3\u0189\3\u0189\3\u0189") + buf.write("\3\u0189\3\u0189\3\u0189\3\u0189\3\u018a\3\u018a\3\u018a") + buf.write("\3\u018b\3\u018b\3\u018b\3\u018b\3\u018b\3\u018c\3\u018c") + buf.write("\3\u018c\3\u018c\3\u018d\3\u018d\3\u018d\3\u018d\3\u018d") + buf.write("\3\u018d\3\u018d\3\u018e\3\u018e\3\u018e\3\u018e\3\u018e") + buf.write("\3\u018e\3\u018f\3\u018f\3\u018f\3\u018f\3\u018f\3\u018f") + buf.write("\3\u0190\3\u0190\3\u0190\3\u0190\3\u0191\3\u0191\3\u0191") + buf.write("\3\u0191\3\u0191\3\u0191\3\u0191\3\u0191\3\u0192\3\u0192") + buf.write("\3\u0192\3\u0192\3\u0192\3\u0193\3\u0193\3\u0193\3\u0193") + buf.write("\3\u0193\3\u0193\3\u0194\3\u0194\3\u0194\3\u0194\3\u0194") + buf.write("\3\u0194\3\u0195\3\u0195\3\u0195\3\u0195\3\u0195\3\u0195") + buf.write("\3\u0195\3\u0196\3\u0196\3\u0196\3\u0197\3\u0197\3\u0197") + buf.write("\3\u0197\3\u0197\3\u0197\3\u0197\3\u0197\3\u0197\3\u0197") + buf.write("\3\u0198\3\u0198\3\u0198\3\u0198\3\u0198\3\u0198\3\u0198") + buf.write("\3\u0198\3\u0198\3\u0198\3\u0199\3\u0199\3\u0199\3\u0199") + buf.write("\3\u0199\3\u019a\3\u019a\3\u019a\3\u019a\3\u019a\3\u019a") + buf.write("\3\u019a\3\u019a\3\u019b\3\u019b\3\u019b\3\u019b\3\u019b") + buf.write("\3\u019b\3\u019b\3\u019b\3\u019c\3\u019c\3\u019c\3\u019c") + buf.write("\3\u019c\3\u019c\3\u019d\3\u019d\3\u019d\3\u019d\3\u019d") + buf.write("\3\u019d\3\u019d\3\u019d\3\u019d\3\u019d\3\u019e\3\u019e") + buf.write("\3\u019e\3\u019e\3\u019e\3\u019e\3\u019e\3\u019e\3\u019e") + buf.write("\3\u019e\3\u019e\3\u019e\3\u019e\3\u019e\3\u019e\3\u019f") + buf.write("\3\u019f\3\u019f\3\u019f\3\u01a0\3\u01a0\3\u01a0\3\u01a0") + buf.write("\3\u01a0\3\u01a1\3\u01a1\3\u01a1\3\u01a1\3\u01a1\3\u01a1") + buf.write("\3\u01a1\3\u01a2\3\u01a2\3\u01a2\3\u01a3\3\u01a3\3\u01a3") + buf.write("\3\u01a3\3\u01a3\3\u01a4\3\u01a4\3\u01a4\3\u01a5\3\u01a5") + buf.write("\3\u01a5\3\u01a5\3\u01a5\3\u01a5\3\u01a6\3\u01a6\3\u01a6") + buf.write("\3\u01a6\3\u01a6\3\u01a6\3\u01a6\3\u01a6\3\u01a7\3\u01a7") + buf.write("\3\u01a7\3\u01a7\3\u01a7\3\u01a7\3\u01a7\3\u01a7\3\u01a8") + buf.write("\3\u01a8\3\u01a8\3\u01a8\3\u01a8\3\u01a8\3\u01a8\3\u01a8") + buf.write("\3\u01a8\3\u01a8\3\u01a8\3\u01a9\3\u01a9\3\u01a9\3\u01a9") + buf.write("\3\u01a9\3\u01a9\3\u01a9\3\u01a9\3\u01a9\3\u01a9\3\u01aa") + buf.write("\3\u01aa\3\u01aa\3\u01aa\3\u01aa\3\u01aa\3\u01aa\3\u01ab") + buf.write("\3\u01ab\3\u01ab\3\u01ab\3\u01ab\3\u01ab\3\u01ab\3\u01ab") + buf.write("\3\u01ab\3\u01ab\3\u01ab\3\u01ab\3\u01ab\3\u01ac\3\u01ac") + buf.write("\3\u01ac\3\u01ac\3\u01ac\3\u01ad\3\u01ad\3\u01ad\3\u01ad") + buf.write("\3\u01ad\3\u01ad\3\u01ad\3\u01ad\3\u01ad\3\u01ad\3\u01ae") + buf.write("\3\u01ae\3\u01ae\3\u01ae\3\u01ae\3\u01ae\3\u01af\3\u01af") + buf.write("\3\u01af\3\u01af\3\u01af\3\u01b0\3\u01b0\3\u01b0\3\u01b1") + buf.write("\3\u01b1\3\u01b1\3\u01b1\3\u01b1\3\u01b1\3\u01b1\3\u01b1") + buf.write("\3\u01b1\3\u01b2\3\u01b2\3\u01b2\3\u01b2\3\u01b2\3\u01b3") + buf.write("\3\u01b3\3\u01b3\3\u01b3\3\u01b3\3\u01b3\3\u01b4\3\u01b4") + buf.write("\3\u01b4\3\u01b4\3\u01b4\3\u01b4\3\u01b4\3\u01b5\3\u01b5") + buf.write("\3\u01b5\3\u01b5\3\u01b5\3\u01b6\3\u01b6\3\u01b6\3\u01b6") + buf.write("\3\u01b6\3\u01b6\3\u01b7\3\u01b7\3\u01b7\3\u01b7\3\u01b7") + buf.write("\3\u01b7\3\u01b7\3\u01b7\3\u01b7\3\u01b8\3\u01b8\3\u01b8") + buf.write("\3\u01b8\3\u01b8\3\u01b9\3\u01b9\3\u01b9\3\u01b9\3\u01b9") + buf.write("\3\u01b9\3\u01ba\3\u01ba\3\u01ba\3\u01ba\3\u01ba\3\u01ba") + buf.write("\3\u01ba\3\u01bb\3\u01bb\3\u01bb\3\u01bb\3\u01bb\3\u01bc") + buf.write("\3\u01bc\3\u01bc\3\u01bc\3\u01bc\3\u01bc\3\u01bc\3\u01bc") + buf.write("\3\u01bc\3\u01bc\3\u01bd\3\u01bd\3\u01bd\3\u01bd\3\u01bd") + buf.write("\3\u01bd\3\u01bd\3\u01bd\3\u01bd\3\u01be\3\u01be\3\u01be") + buf.write("\3\u01be\3\u01be\3\u01be\3\u01be\3\u01be\3\u01bf\3\u01bf") + buf.write("\3\u01bf\3\u01bf\3\u01bf\3\u01bf\3\u01bf\3\u01bf\3\u01bf") + buf.write("\3\u01bf\3\u01c0\3\u01c0\3\u01c0\3\u01c0\3\u01c0\3\u01c0") + buf.write("\3\u01c0\3\u01c0\3\u01c0\3\u01c0\3\u01c1\3\u01c1\3\u01c1") + buf.write("\3\u01c1\3\u01c1\3\u01c1\3\u01c1\3\u01c1\3\u01c1\3\u01c2") + buf.write("\3\u01c2\3\u01c2\3\u01c2\3\u01c2\3\u01c2\3\u01c2\3\u01c2") + buf.write("\3\u01c2\3\u01c2\3\u01c2\3\u01c3\3\u01c3\3\u01c3\3\u01c3") + buf.write("\3\u01c3\3\u01c3\3\u01c3\3\u01c3\3\u01c3\3\u01c3\3\u01c3") + buf.write("\3\u01c3\3\u01c4\3\u01c4\3\u01c4\3\u01c4\3\u01c4\3\u01c4") + buf.write("\3\u01c4\3\u01c4\3\u01c4\3\u01c4\3\u01c4\3\u01c5\3\u01c5") + buf.write("\3\u01c5\3\u01c5\3\u01c5\3\u01c5\3\u01c5\3\u01c5\3\u01c6") + buf.write("\3\u01c6\3\u01c6\3\u01c6\3\u01c6\3\u01c6\3\u01c7\3\u01c7") + buf.write("\3\u01c7\3\u01c7\3\u01c7\3\u01c7\3\u01c7\3\u01c7\3\u01c7") + buf.write("\3\u01c8\3\u01c8\3\u01c8\3\u01c8\3\u01c8\3\u01c8\3\u01c8") + buf.write("\3\u01c8\3\u01c8\3\u01c8\3\u01c8\3\u01c9\3\u01c9\3\u01c9") + buf.write("\3\u01c9\3\u01c9\3\u01c9\3\u01c9\3\u01c9\3\u01c9\3\u01c9") + buf.write("\3\u01c9\3\u01c9\3\u01c9\3\u01ca\3\u01ca\3\u01ca\3\u01ca") + buf.write("\3\u01ca\3\u01ca\3\u01ca\3\u01ca\3\u01ca\3\u01ca\3\u01ca") + buf.write("\3\u01ca\3\u01ca\3\u01ca\3\u01cb\3\u01cb\3\u01cb\3\u01cb") + buf.write("\3\u01cb\3\u01cb\3\u01cb\3\u01cb\3\u01cb\3\u01cb\3\u01cb") + buf.write("\3\u01cb\3\u01cb\3\u01cb\3\u01cb\3\u01cb\3\u01cc\3\u01cc") + buf.write("\3\u01cc\3\u01cc\3\u01cc\3\u01cc\3\u01cc\3\u01cc\3\u01cd") + buf.write("\3\u01cd\3\u01cd\3\u01cd\3\u01cd\3\u01cd\3\u01cd\3\u01cd") + buf.write("\3\u01cd\3\u01ce\3\u01ce\3\u01ce\3\u01ce\3\u01ce\3\u01ce") + buf.write("\3\u01ce\3\u01ce\3\u01ce\3\u01ce\3\u01cf\3\u01cf\3\u01cf") + buf.write("\3\u01cf\3\u01cf\3\u01cf\3\u01cf\3\u01cf\3\u01d0\3\u01d0") + buf.write("\3\u01d0\3\u01d0\3\u01d0\3\u01d0\3\u01d0\3\u01d0\3\u01d0") + buf.write("\3\u01d1\3\u01d1\3\u01d1\3\u01d1\3\u01d1\3\u01d1\3\u01d1") + buf.write("\3\u01d1\3\u01d1\3\u01d1\3\u01d1\3\u01d1\3\u01d1\3\u01d1") + buf.write("\3\u01d1\3\u01d2\3\u01d2\3\u01d2\3\u01d2\3\u01d2\3\u01d2") + buf.write("\3\u01d2\3\u01d2\3\u01d2\3\u01d2\3\u01d2\3\u01d3\3\u01d3") + buf.write("\3\u01d3\3\u01d3\3\u01d3\3\u01d3\3\u01d3\3\u01d3\3\u01d3") + buf.write("\3\u01d3\3\u01d3\3\u01d3\3\u01d4\3\u01d4\3\u01d4\3\u01d4") + buf.write("\3\u01d4\3\u01d4\3\u01d4\3\u01d5\3\u01d5\3\u01d5\3\u01d5") + buf.write("\3\u01d5\3\u01d5\3\u01d5\3\u01d5\3\u01d5\3\u01d6\3\u01d6") + buf.write("\3\u01d6\3\u01d6\3\u01d6\3\u01d7\3\u01d7\3\u01d7\3\u01d7") + buf.write("\3\u01d7\3\u01d7\3\u01d7\3\u01d8\3\u01d8\3\u01d8\3\u01d8") + buf.write("\3\u01d8\3\u01d8\3\u01d8\3\u01d8\3\u01d8\3\u01d9\3\u01d9") + buf.write("\3\u01d9\3\u01d9\3\u01d9\3\u01d9\3\u01d9\3\u01d9\3\u01d9") + buf.write("\3\u01d9\3\u01d9\3\u01d9\3\u01d9\3\u01da\3\u01da\3\u01da") + buf.write("\3\u01da\3\u01da\3\u01da\3\u01da\3\u01da\3\u01da\3\u01da") + buf.write("\3\u01da\3\u01da\3\u01da\3\u01da\3\u01db\3\u01db\3\u01db") + buf.write("\3\u01db\3\u01db\3\u01dc\3\u01dc\3\u01dc\3\u01dc\3\u01dc") + buf.write("\3\u01dc\3\u01dc\3\u01dc\3\u01dc\3\u01dd\3\u01dd\3\u01dd") + buf.write("\3\u01dd\3\u01dd\3\u01dd\3\u01dd\3\u01dd\3\u01dd\3\u01dd") + buf.write("\3\u01dd\3\u01dd\3\u01dd\3\u01dd\3\u01dd\3\u01de\3\u01de") + buf.write("\3\u01de\3\u01de\3\u01de\3\u01df\3\u01df\3\u01df\3\u01df") + buf.write("\3\u01df\3\u01df\3\u01df\3\u01df\3\u01df\3\u01df\3\u01df") + buf.write("\3\u01e0\3\u01e0\3\u01e0\3\u01e0\3\u01e0\3\u01e0\3\u01e0") + buf.write("\3\u01e0\3\u01e0\3\u01e1\3\u01e1\3\u01e1\3\u01e1\3\u01e1") + buf.write("\3\u01e1\3\u01e1\3\u01e1\3\u01e2\3\u01e2\3\u01e2\3\u01e2") + buf.write("\3\u01e2\3\u01e2\3\u01e2\3\u01e3\3\u01e3\3\u01e3\3\u01e3") + buf.write("\3\u01e3\3\u01e3\3\u01e3\3\u01e3\3\u01e3\3\u01e4\3\u01e4") + buf.write("\3\u01e4\3\u01e4\3\u01e4\3\u01e5\3\u01e5\3\u01e5\3\u01e5") + buf.write("\3\u01e5\3\u01e5\3\u01e5\3\u01e6\3\u01e6\3\u01e6\3\u01e6") + buf.write("\3\u01e6\3\u01e6\3\u01e7\3\u01e7\3\u01e7\3\u01e7\3\u01e7") + buf.write("\3\u01e8\3\u01e8\3\u01e8\3\u01e8\3\u01e8\3\u01e8\3\u01e8") + buf.write("\3\u01e9\3\u01e9\3\u01e9\3\u01e9\3\u01e9\3\u01e9\3\u01e9") + buf.write("\3\u01e9\3\u01e9\3\u01e9\3\u01e9\3\u01ea\3\u01ea\3\u01ea") + buf.write("\3\u01ea\3\u01ea\3\u01ea\3\u01ea\3\u01ea\3\u01eb\3\u01eb") + buf.write("\3\u01eb\3\u01eb\3\u01eb\3\u01eb\3\u01eb\3\u01eb\3\u01eb") + buf.write("\3\u01ec\3\u01ec\3\u01ec\3\u01ec\3\u01ec\3\u01ec\3\u01ec") + buf.write("\3\u01ec\3\u01ec\3\u01ec\3\u01ed\3\u01ed\3\u01ed\3\u01ed") + buf.write("\3\u01ed\3\u01ed\3\u01ed\3\u01ed\3\u01ed\3\u01ee\3\u01ee") + buf.write("\3\u01ee\3\u01ee\3\u01ee\3\u01ee\3\u01ee\3\u01ee\3\u01ef") + buf.write("\3\u01ef\3\u01ef\3\u01ef\3\u01ef\3\u01ef\3\u01ef\3\u01f0") + buf.write("\3\u01f0\3\u01f0\3\u01f0\3\u01f0\3\u01f0\3\u01f0\3\u01f0") + buf.write("\3\u01f1\3\u01f1\3\u01f1\3\u01f1\3\u01f1\3\u01f1\3\u01f1") + buf.write("\3\u01f2\3\u01f2\3\u01f2\3\u01f2\3\u01f2\3\u01f2\3\u01f2") + buf.write("\3\u01f2\3\u01f3\3\u01f3\3\u01f3\3\u01f3\3\u01f3\3\u01f3") + buf.write("\3\u01f3\3\u01f3\3\u01f3\3\u01f3\3\u01f3\3\u01f3\3\u01f4") + buf.write("\3\u01f4\3\u01f4\3\u01f4\3\u01f4\3\u01f4\3\u01f4\3\u01f4") + buf.write("\3\u01f4\3\u01f4\3\u01f4\3\u01f5\3\u01f5\3\u01f5\3\u01f5") + buf.write("\3\u01f5\3\u01f5\3\u01f5\3\u01f5\3\u01f5\3\u01f5\3\u01f5") + buf.write("\3\u01f5\3\u01f5\3\u01f6\3\u01f6\3\u01f6\3\u01f6\3\u01f6") + buf.write("\3\u01f6\3\u01f6\3\u01f6\3\u01f6\3\u01f6\3\u01f7\3\u01f7") + buf.write("\3\u01f7\3\u01f7\3\u01f7\3\u01f7\3\u01f7\3\u01f7\3\u01f8") + buf.write("\3\u01f8\3\u01f8\3\u01f8\3\u01f8\3\u01f8\3\u01f8\3\u01f8") + buf.write("\3\u01f8\3\u01f8\3\u01f8\3\u01f8\3\u01f8\3\u01f8\3\u01f9") + buf.write("\3\u01f9\3\u01f9\3\u01f9\3\u01f9\3\u01f9\3\u01f9\3\u01f9") + buf.write("\3\u01f9\3\u01f9\3\u01f9\3\u01f9\3\u01fa\3\u01fa\3\u01fa") + buf.write("\3\u01fa\3\u01fa\3\u01fa\3\u01fa\3\u01fb\3\u01fb\3\u01fb") + buf.write("\3\u01fb\3\u01fb\3\u01fb\3\u01fb\3\u01fb\3\u01fb\3\u01fb") + buf.write("\3\u01fb\3\u01fb\3\u01fb\3\u01fb\3\u01fc\3\u01fc\3\u01fc") + buf.write("\3\u01fc\3\u01fc\3\u01fd\3\u01fd\3\u01fd\3\u01fd\3\u01fd") + buf.write("\3\u01fd\3\u01fd\3\u01fd\3\u01fd\3\u01fd\3\u01fd\3\u01fe") + buf.write("\3\u01fe\3\u01fe\3\u01fe\3\u01fe\3\u01fe\3\u01ff\3\u01ff") + buf.write("\3\u01ff\3\u01ff\3\u01ff\3\u01ff\3\u01ff\3\u01ff\3\u01ff") + buf.write("\3\u01ff\3\u0200\3\u0200\3\u0200\3\u0200\3\u0200\3\u0200") + buf.write("\3\u0200\3\u0200\3\u0200\3\u0201\3\u0201\3\u0201\3\u0201") + buf.write("\3\u0202\3\u0202\3\u0202\3\u0202\3\u0203\3\u0203\3\u0203") + buf.write("\3\u0203\3\u0203\3\u0203\3\u0203\3\u0203\3\u0204\3\u0204") + buf.write("\3\u0204\3\u0204\3\u0204\3\u0204\3\u0204\3\u0204\3\u0204") + buf.write("\3\u0204\3\u0205\3\u0205\3\u0205\3\u0205\3\u0205\3\u0205") + buf.write("\3\u0205\3\u0205\3\u0205\3\u0205\3\u0205\3\u0205\3\u0206") + buf.write("\3\u0206\3\u0206\3\u0206\3\u0206\3\u0206\3\u0206\3\u0206") + buf.write("\3\u0206\3\u0206\3\u0206\3\u0207\3\u0207\3\u0207\3\u0207") + buf.write("\3\u0207\3\u0207\3\u0207\3\u0207\3\u0207\3\u0207\3\u0207") + buf.write("\3\u0207\3\u0208\3\u0208\3\u0208\3\u0208\3\u0208\3\u0208") + buf.write("\3\u0208\3\u0208\3\u0208\3\u0209\3\u0209\3\u0209\3\u0209") + buf.write("\3\u0209\3\u020a\3\u020a\3\u020a\3\u020a\3\u020a\3\u020b") + buf.write("\3\u020b\3\u020b\3\u020b\3\u020b\3\u020b\3\u020b\3\u020b") + buf.write("\3\u020b\3\u020b\3\u020b\3\u020c\3\u020c\3\u020c\3\u020c") + buf.write("\3\u020c\3\u020c\3\u020c\3\u020c\3\u020c\3\u020d\3\u020d") + buf.write("\3\u020d\3\u020d\3\u020d\3\u020d\3\u020e\3\u020e\3\u020e") + buf.write("\3\u020e\3\u020e\3\u020e\3\u020e\3\u020e\3\u020e\3\u020e") + buf.write("\3\u020f\3\u020f\3\u020f\3\u020f\3\u020f\3\u020f\3\u020f") + buf.write("\3\u020f\3\u020f\3\u020f\3\u020f\3\u020f\3\u0210\3\u0210") + buf.write("\3\u0210\3\u0210\3\u0210\3\u0210\3\u0210\3\u0211\3\u0211") + buf.write("\3\u0211\3\u0211\3\u0211\3\u0211\3\u0211\3\u0212\3\u0212") + buf.write("\3\u0212\3\u0212\3\u0212\3\u0212\3\u0213\3\u0213\3\u0213") + buf.write("\3\u0213\3\u0213\3\u0213\3\u0213\3\u0213\3\u0213\3\u0213") + buf.write("\3\u0213\3\u0213\3\u0213\3\u0214\3\u0214\3\u0214\3\u0214") + buf.write("\3\u0214\3\u0214\3\u0214\3\u0214\3\u0214\3\u0214\3\u0214") + buf.write("\3\u0214\3\u0214\3\u0214\3\u0214\3\u0214\3\u0215\3\u0215") + buf.write("\3\u0215\3\u0215\3\u0215\3\u0215\3\u0215\3\u0215\3\u0216") + buf.write("\3\u0216\3\u0216\3\u0216\3\u0216\3\u0216\3\u0216\3\u0216") + buf.write("\3\u0217\3\u0217\3\u0217\3\u0217\3\u0217\3\u0217\3\u0217") + buf.write("\3\u0217\3\u0217\3\u0217\3\u0218\3\u0218\3\u0218\3\u0218") + buf.write("\3\u0218\3\u0218\3\u0218\3\u0219\3\u0219\3\u0219\3\u0219") + buf.write("\3\u0219\3\u0219\3\u0219\3\u0219\3\u0219\3\u0219\3\u021a") + buf.write("\3\u021a\3\u021a\3\u021a\3\u021a\3\u021a\3\u021a\3\u021a") + buf.write("\3\u021a\3\u021a\3\u021a\3\u021b\3\u021b\3\u021b\3\u021b") + buf.write("\3\u021b\3\u021b\3\u021b\3\u021c\3\u021c\3\u021c\3\u021c") + buf.write("\3\u021c\3\u021c\3\u021d\3\u021d\3\u021d\3\u021d\3\u021d") + buf.write("\3\u021d\3\u021d\3\u021d\3\u021d\3\u021e\3\u021e\3\u021e") + buf.write("\3\u021e\3\u021e\3\u021f\3\u021f\3\u021f\3\u021f\3\u021f") + buf.write("\3\u021f\3\u0220\3\u0220\3\u0220\3\u0220\3\u0220\3\u0220") + buf.write("\3\u0220\3\u0221\3\u0221\3\u0221\3\u0221\3\u0221\3\u0221") + buf.write("\3\u0221\3\u0221\3\u0221\3\u0222\3\u0222\3\u0222\3\u0222") + buf.write("\3\u0222\3\u0222\3\u0222\3\u0222\3\u0222\3\u0223\3\u0223") + buf.write("\3\u0223\3\u0223\3\u0223\3\u0223\3\u0224\3\u0224\3\u0224") + buf.write("\3\u0224\3\u0224\3\u0224\3\u0224\3\u0225\3\u0225\3\u0225") + buf.write("\3\u0225\3\u0225\3\u0225\3\u0225\3\u0225\3\u0225\3\u0225") + buf.write("\3\u0225\3\u0225\3\u0226\3\u0226\3\u0226\3\u0226\3\u0226") + buf.write("\3\u0226\3\u0226\3\u0227\3\u0227\3\u0227\3\u0227\3\u0227") + buf.write("\3\u0227\3\u0228\3\u0228\3\u0228\3\u0228\3\u0228\3\u0228") + buf.write("\3\u0228\3\u0228\3\u0229\3\u0229\3\u0229\3\u0229\3\u0229") + buf.write("\3\u022a\3\u022a\3\u022a\3\u022a\3\u022a\3\u022a\3\u022a") + buf.write("\3\u022a\3\u022a\3\u022a\3\u022b\3\u022b\3\u022b\3\u022b") + buf.write("\3\u022b\3\u022b\3\u022b\3\u022b\3\u022c\3\u022c\3\u022c") + buf.write("\3\u022c\3\u022d\3\u022d\3\u022d\3\u022d\3\u022d\3\u022e") + buf.write("\3\u022e\3\u022e\3\u022e\3\u022e\3\u022f\3\u022f\3\u022f") + buf.write("\3\u022f\3\u0230\3\u0230\3\u0230\3\u0230\3\u0230\3\u0231") + buf.write("\3\u0231\3\u0231\3\u0231\3\u0231\3\u0231\3\u0231\3\u0231") + buf.write("\3\u0232\3\u0232\3\u0232\3\u0232\3\u0232\3\u0232\3\u0232") + buf.write("\3\u0233\3\u0233\3\u0233\3\u0233\3\u0233\3\u0234\3\u0234") + buf.write("\3\u0234\3\u0234\3\u0234\3\u0234\3\u0234\3\u0234\3\u0235") + buf.write("\3\u0235\3\u0235\3\u0235\3\u0235\3\u0235\3\u0236\3\u0236") + buf.write("\3\u0236\3\u0236\3\u0236\3\u0236\3\u0237\3\u0237\3\u0237") + buf.write("\3\u0237\3\u0237\3\u0237\3\u0237\3\u0238\3\u0238\3\u0238") + buf.write("\3\u0238\3\u0238\3\u0238\3\u0238\3\u0239\3\u0239\3\u0239") + buf.write("\3\u0239\3\u0239\3\u0239\3\u0239\3\u0239\3\u023a\3\u023a") + buf.write("\3\u023a\3\u023a\3\u023a\3\u023a\3\u023a\3\u023a\3\u023b") + buf.write("\3\u023b\3\u023b\3\u023b\3\u023b\3\u023b\3\u023c\3\u023c") + buf.write("\3\u023c\3\u023c\3\u023c\3\u023c\3\u023c\3\u023c\3\u023c") + buf.write("\3\u023d\3\u023d\3\u023d\3\u023d\3\u023d\3\u023d\3\u023d") + buf.write("\3\u023d\3\u023e\3\u023e\3\u023e\3\u023e\3\u023e\3\u023e") + buf.write("\3\u023e\3\u023e\3\u023f\3\u023f\3\u023f\3\u023f\3\u023f") + buf.write("\3\u023f\3\u0240\3\u0240\3\u0241\3\u0241\3\u0241\3\u0242") + buf.write("\3\u0242\3\u0243\3\u0243\3\u0244\3\u0244\3\u0245\3\u0245") + buf.write("\3\u0246\3\u0246\3\u0246\3\u0246\5\u0246\u169a\n\u0246") + buf.write("\3\u0247\3\u0247\3\u0248\3\u0248\3\u0248\3\u0249\3\u0249") + buf.write("\3\u024a\3\u024a\3\u024a\3\u024b\3\u024b\3\u024c\3\u024c") + buf.write("\3\u024d\3\u024d\3\u024e\3\u024e\3\u024f\3\u024f\3\u0250") + buf.write("\3\u0250\3\u0251\3\u0251\3\u0252\3\u0252\3\u0253\3\u0253") + buf.write("\3\u0254\3\u0254\3\u0255\3\u0255\3\u0256\3\u0256\3\u0257") + buf.write("\3\u0257\3\u0258\3\u0258\3\u0259\3\u0259\3\u0259\3\u025a") + buf.write("\3\u025a\3\u025a\3\u025b\3\u025b\3\u025b\3\u025c\3\u025c") + buf.write("\3\u025c\3\u025d\3\u025d\3\u025d\3\u025e\3\u025e\3\u025f") + buf.write("\3\u025f\3\u025f\3\u025f\3\u025f\7\u025f\u16d8\n\u025f") + buf.write("\f\u025f\16\u025f\u16db\13\u025f\3\u025f\3\u025f\3\u025f") + buf.write("\3\u025f\3\u025f\3\u0260\3\u0260\3\u0260\3\u0260\7\u0260") + buf.write("\u16e6\n\u0260\f\u0260\16\u0260\u16e9\13\u0260\3\u0260") + buf.write("\3\u0260\3\u0261\6\u0261\u16ee\n\u0261\r\u0261\16\u0261") + buf.write("\u16ef\3\u0261\3\u0261\3\u0261\3\u0261\7\u0261\u16f6\n") + buf.write("\u0261\f\u0261\16\u0261\u16f9\13\u0261\3\u0261\3\u0261") + buf.write("\3\u0261\7\u0261\u16fe\n\u0261\f\u0261\16\u0261\u1701") + buf.write("\13\u0261\5\u0261\u1703\n\u0261\3\u0262\3\u0262\3\u0262") + buf.write("\3\u0262\3\u0262\5\u0262\u170a\n\u0262\3\u0263\3\u0263") + buf.write("\3\u0264\3\u0264\3\u0265\6\u0265\u1711\n\u0265\r\u0265") + buf.write("\16\u0265\u1712\3\u0266\3\u0266\3\u0267\6\u0267\u1718") + buf.write("\n\u0267\r\u0267\16\u0267\u1719\3\u0267\3\u0267\3\u0267") + buf.write("\3\u0267\6\u0267\u1720\n\u0267\r\u0267\16\u0267\u1721") + buf.write("\3\u0267\3\u0267\6\u0267\u1726\n\u0267\r\u0267\16\u0267") + buf.write("\u1727\3\u0267\5\u0267\u172b\n\u0267\3\u0267\6\u0267\u172e") + buf.write("\n\u0267\r\u0267\16\u0267\u172f\3\u0267\3\u0267\3\u0267") + buf.write("\3\u0267\3\u0267\6\u0267\u1737\n\u0267\r\u0267\16\u0267") + buf.write("\u1738\3\u0267\5\u0267\u173c\n\u0267\3\u0267\6\u0267\u173f") + buf.write("\n\u0267\r\u0267\16\u0267\u1740\3\u0267\3\u0267\5\u0267") + buf.write("\u1745\n\u0267\3\u0268\3\u0268\3\u0268\3\u0269\3\u0269") + buf.write("\7\u0269\u174c\n\u0269\f\u0269\16\u0269\u174f\13\u0269") + buf.write("\3\u0269\3\u0269\3\u026a\3\u026a\3\u026a\3\u026a\3\u026a") + buf.write("\3\u026a\5\u026a\u1759\n\u026a\3\u026b\3\u026b\5\u026b") + buf.write("\u175d\n\u026b\3\u026c\3\u026c\5\u026c\u1761\n\u026c\3") + buf.write("\u026d\3\u026d\3\u026d\3\u026d\3\u026e\3\u026e\3\u026e") + buf.write("\3\u026e\7\u026e\u176b\n\u026e\f\u026e\16\u026e\u176e") + buf.write("\13\u026e\3\u026f\3\u026f\3\u0270\3\u0270\3\u0271\5\u0271") + buf.write("\u1775\n\u0271\3\u0271\3\u0271\3\u0271\3\u0271\7\u0271") + buf.write("\u177b\n\u0271\f\u0271\16\u0271\u177e\13\u0271\3\u0272") + buf.write("\3\u0272\3\u0272\3\u0272\7\u0272\u1784\n\u0272\f\u0272") + buf.write("\16\u0272\u1787\13\u0272\3\u0272\3\u0272\3\u0273\3\u0273") + buf.write("\3\u0273\3\u0273\7\u0273\u178f\n\u0273\f\u0273\16\u0273") + buf.write("\u1792\13\u0273\3\u0273\6\u0273\u1795\n\u0273\r\u0273") + buf.write("\16\u0273\u1796\3\u0273\3\u0273\3\u0273\7\u0273\u179c") + buf.write("\n\u0273\f\u0273\16\u0273\u179f\13\u0273\3\u0274\3\u0274") + buf.write("\5\u0274\u17a3\n\u0274\3\u0274\6\u0274\u17a6\n\u0274\r") + buf.write("\u0274\16\u0274\u17a7\3\u0275\3\u0275\5\u0275\u17ac\n") + buf.write("\u0275\3\u0275\3\u0275\3\u0275\3\u0275\3\u0275\3\u0276") + buf.write("\3\u0276\7\u0276\u17b5\n\u0276\f\u0276\16\u0276\u17b8") + buf.write("\13\u0276\3\u0277\3\u0277\3\u0277\3\u0277\3\u0278\3\u0278") + buf.write("\6\u0278\u17c0\n\u0278\r\u0278\16\u0278\u17c1\3\u0278") + buf.write("\3\u0278\3\u0279\3\u0279\5\u0279\u17c8\n\u0279\3\u0279") + buf.write("\5\u0279\u17cb\n\u0279\3\u0279\3\u0279\3\u027a\3\u027a") + buf.write("\3\u027a\3\u027a\3\u027b\3\u027b\3\u027c\3\u027c\3\u027d") + buf.write("\6\u027d\u17d8\n\u027d\r\u027d\16\u027d\u17d9\3\u027d") + buf.write("\3\u027d\7\u027d\u17de\n\u027d\f\u027d\16\u027d\u17e1") + buf.write("\13\u027d\5\u027d\u17e3\n\u027d\3\u027e\3\u027e\5\u027e") + buf.write("\u17e7\n\u027e\3\u027e\3\u027e\3\u027e\3\u027e\3\u027e") + buf.write("\3\u027e\3\u16d9\2\u027f\4\3\6\4\b\5\n\6\f\7\16\b\20\t") + buf.write("\22\n\24\13\26\f\30\r\32\16\34\17\36\20 \21\"\22$\23&") + buf.write("\24(\25*\26,\27.\30\60\31\62\32\64\33\66\348\35:\36<\37") + buf.write("> @!B\"D#F$H%J&L\'N(P)R*T+V,X-Z.\\/^\60`\61b\62d\63f\64") + buf.write("h\65j\66l\67n8p9r:t;v|?~@\u0080A\u0082B\u0084C\u0086") + buf.write("D\u0088E\u008aF\u008cG\u008eH\u0090I\u0092J\u0094K\u0096") + buf.write("L\u0098M\u009aN\u009cO\u009eP\u00a0Q\u00a2R\u00a4S\u00a6") + buf.write("T\u00a8U\u00aaV\u00acW\u00aeX\u00b0Y\u00b2Z\u00b4[\u00b6") + buf.write("\\\u00b8]\u00ba^\u00bc_\u00be`\u00c0a\u00c2b\u00c4c\u00c6") + buf.write("d\u00c8e\u00caf\u00ccg\u00ceh\u00d0i\u00d2j\u00d4k\u00d6") + buf.write("l\u00d8m\u00dan\u00dco\u00dep\u00e0q\u00e2r\u00e4s\u00e6") + buf.write("t\u00e8u\u00eav\u00ecw\u00eex\u00f0y\u00f2z\u00f4{\u00f6") + buf.write("|\u00f8}\u00fa~\u00fc\177\u00fe\u0080\u0100\u0081\u0102") + buf.write("\u0082\u0104\u0083\u0106\u0084\u0108\u0085\u010a\u0086") + buf.write("\u010c\u0087\u010e\u0088\u0110\u0089\u0112\u008a\u0114") + buf.write("\u008b\u0116\u008c\u0118\u008d\u011a\u008e\u011c\u008f") + buf.write("\u011e\u0090\u0120\u0091\u0122\u0092\u0124\u0093\u0126") + buf.write("\u0094\u0128\u0095\u012a\u0096\u012c\u0097\u012e\u0098") + buf.write("\u0130\u0099\u0132\u009a\u0134\u009b\u0136\u009c\u0138") + buf.write("\u009d\u013a\u009e\u013c\u009f\u013e\u00a0\u0140\u00a1") + buf.write("\u0142\u00a2\u0144\u00a3\u0146\u00a4\u0148\u00a5\u014a") + buf.write("\u00a6\u014c\u00a7\u014e\u00a8\u0150\u00a9\u0152\u00aa") + buf.write("\u0154\u00ab\u0156\u00ac\u0158\u00ad\u015a\u00ae\u015c") + buf.write("\u00af\u015e\u00b0\u0160\u00b1\u0162\u00b2\u0164\u00b3") + buf.write("\u0166\u00b4\u0168\u00b5\u016a\u00b6\u016c\u00b7\u016e") + buf.write("\u00b8\u0170\u00b9\u0172\u00ba\u0174\u00bb\u0176\u00bc") + buf.write("\u0178\u00bd\u017a\u00be\u017c\u00bf\u017e\u00c0\u0180") + buf.write("\u00c1\u0182\u00c2\u0184\u00c3\u0186\u00c4\u0188\u00c5") + buf.write("\u018a\u00c6\u018c\u00c7\u018e\u00c8\u0190\u00c9\u0192") + buf.write("\u00ca\u0194\u00cb\u0196\u00cc\u0198\u00cd\u019a\u00ce") + buf.write("\u019c\u00cf\u019e\u00d0\u01a0\u00d1\u01a2\u00d2\u01a4") + buf.write("\u00d3\u01a6\u00d4\u01a8\u00d5\u01aa\u00d6\u01ac\u00d7") + buf.write("\u01ae\u00d8\u01b0\u00d9\u01b2\u00da\u01b4\u00db\u01b6") + buf.write("\u00dc\u01b8\u00dd\u01ba\u00de\u01bc\u00df\u01be\u00e0") + buf.write("\u01c0\u00e1\u01c2\u00e2\u01c4\u00e3\u01c6\u00e4\u01c8") + buf.write("\u00e5\u01ca\u00e6\u01cc\u00e7\u01ce\u00e8\u01d0\u00e9") + buf.write("\u01d2\u00ea\u01d4\u00eb\u01d6\u00ec\u01d8\u00ed\u01da") + buf.write("\u00ee\u01dc\u00ef\u01de\u00f0\u01e0\u00f1\u01e2\u00f2") + buf.write("\u01e4\u00f3\u01e6\u00f4\u01e8\u00f5\u01ea\u00f6\u01ec") + buf.write("\u00f7\u01ee\u00f8\u01f0\u00f9\u01f2\u00fa\u01f4\u00fb") + buf.write("\u01f6\u00fc\u01f8\u00fd\u01fa\u00fe\u01fc\u00ff\u01fe") + buf.write("\u0100\u0200\u0101\u0202\u0102\u0204\u0103\u0206\u0104") + buf.write("\u0208\u0105\u020a\u0106\u020c\u0107\u020e\u0108\u0210") + buf.write("\u0109\u0212\u010a\u0214\u010b\u0216\u010c\u0218\u010d") + buf.write("\u021a\u010e\u021c\u010f\u021e\u0110\u0220\u0111\u0222") + buf.write("\u0112\u0224\u0113\u0226\u0114\u0228\u0115\u022a\u0116") + buf.write("\u022c\u0117\u022e\u0118\u0230\u0119\u0232\u011a\u0234") + buf.write("\u011b\u0236\u011c\u0238\u011d\u023a\u011e\u023c\u011f") + buf.write("\u023e\u0120\u0240\u0121\u0242\u0122\u0244\u0123\u0246") + buf.write("\u0124\u0248\u0125\u024a\u0126\u024c\u0127\u024e\u0128") + buf.write("\u0250\u0129\u0252\u012a\u0254\u012b\u0256\u012c\u0258") + buf.write("\u012d\u025a\u012e\u025c\u012f\u025e\u0130\u0260\u0131") + buf.write("\u0262\u0132\u0264\u0133\u0266\u0134\u0268\u0135\u026a") + buf.write("\u0136\u026c\u0137\u026e\u0138\u0270\u0139\u0272\u013a") + buf.write("\u0274\u013b\u0276\u013c\u0278\u013d\u027a\u013e\u027c") + buf.write("\u013f\u027e\u0140\u0280\u0141\u0282\u0142\u0284\u0143") + buf.write("\u0286\u0144\u0288\u0145\u028a\u0146\u028c\u0147\u028e") + buf.write("\u0148\u0290\u0149\u0292\u014a\u0294\u014b\u0296\u014c") + buf.write("\u0298\u014d\u029a\u014e\u029c\u014f\u029e\u0150\u02a0") + buf.write("\u0151\u02a2\u0152\u02a4\u0153\u02a6\u0154\u02a8\u0155") + buf.write("\u02aa\u0156\u02ac\u0157\u02ae\u0158\u02b0\u0159\u02b2") + buf.write("\u015a\u02b4\u015b\u02b6\u015c\u02b8\u015d\u02ba\u015e") + buf.write("\u02bc\u015f\u02be\u0160\u02c0\u0161\u02c2\u0162\u02c4") + buf.write("\u0163\u02c6\u0164\u02c8\u0165\u02ca\u0166\u02cc\u0167") + buf.write("\u02ce\u0168\u02d0\u0169\u02d2\u016a\u02d4\u016b\u02d6") + buf.write("\u016c\u02d8\u016d\u02da\u016e\u02dc\u016f\u02de\u0170") + buf.write("\u02e0\u0171\u02e2\u0172\u02e4\u0173\u02e6\u0174\u02e8") + buf.write("\u0175\u02ea\u0176\u02ec\u0177\u02ee\u0178\u02f0\u0179") + buf.write("\u02f2\u017a\u02f4\u017b\u02f6\u017c\u02f8\u017d\u02fa") + buf.write("\u017e\u02fc\u017f\u02fe\u0180\u0300\u0181\u0302\u0182") + buf.write("\u0304\u0183\u0306\u0184\u0308\u0185\u030a\u0186\u030c") + buf.write("\u0187\u030e\u0188\u0310\u0189\u0312\u018a\u0314\u018b") + buf.write("\u0316\u018c\u0318\u018d\u031a\u018e\u031c\u018f\u031e") + buf.write("\u0190\u0320\u0191\u0322\u0192\u0324\u0193\u0326\u0194") + buf.write("\u0328\u0195\u032a\u0196\u032c\u0197\u032e\u0198\u0330") + buf.write("\u0199\u0332\u019a\u0334\u019b\u0336\u019c\u0338\u019d") + buf.write("\u033a\u019e\u033c\u019f\u033e\u01a0\u0340\u01a1\u0342") + buf.write("\u01a2\u0344\u01a3\u0346\u01a4\u0348\u01a5\u034a\u01a6") + buf.write("\u034c\u01a7\u034e\u01a8\u0350\u01a9\u0352\u01aa\u0354") + buf.write("\u01ab\u0356\u01ac\u0358\u01ad\u035a\u01ae\u035c\u01af") + buf.write("\u035e\u01b0\u0360\u01b1\u0362\u01b2\u0364\u01b3\u0366") + buf.write("\u01b4\u0368\u01b5\u036a\u01b6\u036c\u01b7\u036e\u01b8") + buf.write("\u0370\u01b9\u0372\u01ba\u0374\u01bb\u0376\u01bc\u0378") + buf.write("\u01bd\u037a\u01be\u037c\u01bf\u037e\u01c0\u0380\u01c1") + buf.write("\u0382\u01c2\u0384\u01c3\u0386\u01c4\u0388\u01c5\u038a") + buf.write("\u01c6\u038c\u01c7\u038e\u01c8\u0390\u01c9\u0392\u01ca") + buf.write("\u0394\u01cb\u0396\u01cc\u0398\u01cd\u039a\u01ce\u039c") + buf.write("\u01cf\u039e\u01d0\u03a0\u01d1\u03a2\u01d2\u03a4\u01d3") + buf.write("\u03a6\u01d4\u03a8\u01d5\u03aa\u01d6\u03ac\u01d7\u03ae") + buf.write("\u01d8\u03b0\u01d9\u03b2\u01da\u03b4\u01db\u03b6\u01dc") + buf.write("\u03b8\u01dd\u03ba\u01de\u03bc\u01df\u03be\u01e0\u03c0") + buf.write("\u01e1\u03c2\u01e2\u03c4\u01e3\u03c6\u01e4\u03c8\u01e5") + buf.write("\u03ca\u01e6\u03cc\u01e7\u03ce\u01e8\u03d0\u01e9\u03d2") + buf.write("\u01ea\u03d4\u01eb\u03d6\u01ec\u03d8\u01ed\u03da\u01ee") + buf.write("\u03dc\u01ef\u03de\u01f0\u03e0\u01f1\u03e2\u01f2\u03e4") + buf.write("\u01f3\u03e6\u01f4\u03e8\u01f5\u03ea\u01f6\u03ec\u01f7") + buf.write("\u03ee\u01f8\u03f0\u01f9\u03f2\u01fa\u03f4\u01fb\u03f6") + buf.write("\u01fc\u03f8\u01fd\u03fa\u01fe\u03fc\u01ff\u03fe\u0200") + buf.write("\u0400\u0201\u0402\u0202\u0404\u0203\u0406\u0204\u0408") + buf.write("\u0205\u040a\u0206\u040c\u0207\u040e\u0208\u0410\u0209") + buf.write("\u0412\u020a\u0414\u020b\u0416\u020c\u0418\u020d\u041a") + buf.write("\u020e\u041c\u020f\u041e\u0210\u0420\u0211\u0422\u0212") + buf.write("\u0424\u0213\u0426\u0214\u0428\u0215\u042a\u0216\u042c") + buf.write("\u0217\u042e\u0218\u0430\u0219\u0432\u021a\u0434\u021b") + buf.write("\u0436\u021c\u0438\u021d\u043a\u021e\u043c\u021f\u043e") + buf.write("\u0220\u0440\u0221\u0442\u0222\u0444\u0223\u0446\u0224") + buf.write("\u0448\u0225\u044a\u0226\u044c\u0227\u044e\u0228\u0450") + buf.write("\u0229\u0452\u022a\u0454\u022b\u0456\u022c\u0458\u022d") + buf.write("\u045a\u022e\u045c\u022f\u045e\u0230\u0460\u0231\u0462") + buf.write("\u0232\u0464\u0233\u0466\u0234\u0468\u0235\u046a\u0236") + buf.write("\u046c\u0237\u046e\u0238\u0470\u0239\u0472\u023a\u0474") + buf.write("\u023b\u0476\u023c\u0478\u023d\u047a\u023e\u047c\u023f") + buf.write("\u047e\u0240\u0480\2\u0482\u0241\u0484\u0242\u0486\u0243") + buf.write("\u0488\u0244\u048a\u0245\u048c\u0246\u048e\u0247\u0490") + buf.write("\u0248\u0492\u0249\u0494\u024a\u0496\u024b\u0498\u024c") + buf.write("\u049a\u024d\u049c\u024e\u049e\u024f\u04a0\u0250\u04a2") + buf.write("\u0251\u04a4\u0252\u04a6\u0253\u04a8\u0254\u04aa\u0255") + buf.write("\u04ac\u0256\u04ae\u0257\u04b0\u0258\u04b2\u0259\u04b4") + buf.write("\u025a\u04b6\u025b\u04b8\u025c\u04ba\u025d\u04bc\u025e") + buf.write("\u04be\u025f\u04c0\u0260\u04c2\u0261\u04c4\2\u04c6\2\u04c8") + buf.write("\2\u04ca\u0262\u04cc\2\u04ce\u0263\u04d0\u0264\u04d2\u0265") + buf.write("\u04d4\2\u04d6\2\u04d8\2\u04da\u0266\u04dc\2\u04de\2\u04e0") + buf.write("\2\u04e2\u0267\u04e4\2\u04e6\2\u04e8\2\u04ea\u0268\u04ec") + buf.write("\2\u04ee\u0269\u04f0\u026a\u04f2\u026b\u04f4\u026c\u04f6") + buf.write("\u026d\u04f8\u026e\u04fa\u026f\u04fc\u0270\4\2\3+\4\2") + buf.write("CCcc\4\2DDdd\4\2QQqq\4\2TTtt\4\2VVvv\4\2UUuu\4\2NNnn\4") + buf.write("\2WWww\4\2GGgg\4\2EEee\4\2KKkk\4\2PPpp\4\2FFff\4\2OOo") + buf.write("o\4\2HHhh\4\2IIii\4\2YYyy\4\2[[{{\4\2JJjj\4\2MMmm\4\2") + buf.write("RRrr\4\2XXxx\4\2ZZzz\4\2\\\\||\4\2LLll\4\2SSss\4\2\f\f") + buf.write("\17\17\4\2,->@\5\2,,\61\61>@\n\2##%%\'(AB``bb~~\u0080") + buf.write("\u0080\13\2C\\aac|\u00ac\u00ac\u00b7\u00b7\u00bc\u00bc") + buf.write("\u00c2\u00d8\u00da\u00f8\u00fa\u0101\4\2\u0102\ud801\ue002") + buf.write("\1\3\2\ud802\udc01\3\2\udc02\ue001\3\2\62;\4\2\2\2$$\5") + buf.write("\2\3\n\r\16\20!\n\2DDGGPPZZddggppzz\3\2))\4\2--//\3\2") + buf.write("&&\2\u1815\2\4\3\2\2\2\2\6\3\2\2\2\2\b\3\2\2\2\2\n\3\2") + buf.write("\2\2\2\f\3\2\2\2\2\16\3\2\2\2\2\20\3\2\2\2\2\22\3\2\2") + buf.write("\2\2\24\3\2\2\2\2\26\3\2\2\2\2\30\3\2\2\2\2\32\3\2\2\2") + buf.write("\2\34\3\2\2\2\2\36\3\2\2\2\2 \3\2\2\2\2\"\3\2\2\2\2$\3") + buf.write("\2\2\2\2&\3\2\2\2\2(\3\2\2\2\2*\3\2\2\2\2,\3\2\2\2\2.") + buf.write("\3\2\2\2\2\60\3\2\2\2\2\62\3\2\2\2\2\64\3\2\2\2\2\66\3") + buf.write("\2\2\2\28\3\2\2\2\2:\3\2\2\2\2<\3\2\2\2\2>\3\2\2\2\2@") + buf.write("\3\2\2\2\2B\3\2\2\2\2D\3\2\2\2\2F\3\2\2\2\2H\3\2\2\2\2") + buf.write("J\3\2\2\2\2L\3\2\2\2\2N\3\2\2\2\2P\3\2\2\2\2R\3\2\2\2") + buf.write("\2T\3\2\2\2\2V\3\2\2\2\2X\3\2\2\2\2Z\3\2\2\2\2\\\3\2\2") + buf.write("\2\2^\3\2\2\2\2`\3\2\2\2\2b\3\2\2\2\2d\3\2\2\2\2f\3\2") + buf.write("\2\2\2h\3\2\2\2\2j\3\2\2\2\2l\3\2\2\2\2n\3\2\2\2\2p\3") + buf.write("\2\2\2\2r\3\2\2\2\2t\3\2\2\2\2v\3\2\2\2\2x\3\2\2\2\2z") + buf.write("\3\2\2\2\2|\3\2\2\2\2~\3\2\2\2\2\u0080\3\2\2\2\2\u0082") + buf.write("\3\2\2\2\2\u0084\3\2\2\2\2\u0086\3\2\2\2\2\u0088\3\2\2") + buf.write("\2\2\u008a\3\2\2\2\2\u008c\3\2\2\2\2\u008e\3\2\2\2\2\u0090") + buf.write("\3\2\2\2\2\u0092\3\2\2\2\2\u0094\3\2\2\2\2\u0096\3\2\2") + buf.write("\2\2\u0098\3\2\2\2\2\u009a\3\2\2\2\2\u009c\3\2\2\2\2\u009e") + buf.write("\3\2\2\2\2\u00a0\3\2\2\2\2\u00a2\3\2\2\2\2\u00a4\3\2\2") + buf.write("\2\2\u00a6\3\2\2\2\2\u00a8\3\2\2\2\2\u00aa\3\2\2\2\2\u00ac") + buf.write("\3\2\2\2\2\u00ae\3\2\2\2\2\u00b0\3\2\2\2\2\u00b2\3\2\2") + buf.write("\2\2\u00b4\3\2\2\2\2\u00b6\3\2\2\2\2\u00b8\3\2\2\2\2\u00ba") + buf.write("\3\2\2\2\2\u00bc\3\2\2\2\2\u00be\3\2\2\2\2\u00c0\3\2\2") + buf.write("\2\2\u00c2\3\2\2\2\2\u00c4\3\2\2\2\2\u00c6\3\2\2\2\2\u00c8") + buf.write("\3\2\2\2\2\u00ca\3\2\2\2\2\u00cc\3\2\2\2\2\u00ce\3\2\2") + buf.write("\2\2\u00d0\3\2\2\2\2\u00d2\3\2\2\2\2\u00d4\3\2\2\2\2\u00d6") + buf.write("\3\2\2\2\2\u00d8\3\2\2\2\2\u00da\3\2\2\2\2\u00dc\3\2\2") + buf.write("\2\2\u00de\3\2\2\2\2\u00e0\3\2\2\2\2\u00e2\3\2\2\2\2\u00e4") + buf.write("\3\2\2\2\2\u00e6\3\2\2\2\2\u00e8\3\2\2\2\2\u00ea\3\2\2") + buf.write("\2\2\u00ec\3\2\2\2\2\u00ee\3\2\2\2\2\u00f0\3\2\2\2\2\u00f2") + buf.write("\3\2\2\2\2\u00f4\3\2\2\2\2\u00f6\3\2\2\2\2\u00f8\3\2\2") + buf.write("\2\2\u00fa\3\2\2\2\2\u00fc\3\2\2\2\2\u00fe\3\2\2\2\2\u0100") + buf.write("\3\2\2\2\2\u0102\3\2\2\2\2\u0104\3\2\2\2\2\u0106\3\2\2") + buf.write("\2\2\u0108\3\2\2\2\2\u010a\3\2\2\2\2\u010c\3\2\2\2\2\u010e") + buf.write("\3\2\2\2\2\u0110\3\2\2\2\2\u0112\3\2\2\2\2\u0114\3\2\2") + buf.write("\2\2\u0116\3\2\2\2\2\u0118\3\2\2\2\2\u011a\3\2\2\2\2\u011c") + buf.write("\3\2\2\2\2\u011e\3\2\2\2\2\u0120\3\2\2\2\2\u0122\3\2\2") + buf.write("\2\2\u0124\3\2\2\2\2\u0126\3\2\2\2\2\u0128\3\2\2\2\2\u012a") + buf.write("\3\2\2\2\2\u012c\3\2\2\2\2\u012e\3\2\2\2\2\u0130\3\2\2") + buf.write("\2\2\u0132\3\2\2\2\2\u0134\3\2\2\2\2\u0136\3\2\2\2\2\u0138") + buf.write("\3\2\2\2\2\u013a\3\2\2\2\2\u013c\3\2\2\2\2\u013e\3\2\2") + buf.write("\2\2\u0140\3\2\2\2\2\u0142\3\2\2\2\2\u0144\3\2\2\2\2\u0146") + buf.write("\3\2\2\2\2\u0148\3\2\2\2\2\u014a\3\2\2\2\2\u014c\3\2\2") + buf.write("\2\2\u014e\3\2\2\2\2\u0150\3\2\2\2\2\u0152\3\2\2\2\2\u0154") + buf.write("\3\2\2\2\2\u0156\3\2\2\2\2\u0158\3\2\2\2\2\u015a\3\2\2") + buf.write("\2\2\u015c\3\2\2\2\2\u015e\3\2\2\2\2\u0160\3\2\2\2\2\u0162") + buf.write("\3\2\2\2\2\u0164\3\2\2\2\2\u0166\3\2\2\2\2\u0168\3\2\2") + buf.write("\2\2\u016a\3\2\2\2\2\u016c\3\2\2\2\2\u016e\3\2\2\2\2\u0170") + buf.write("\3\2\2\2\2\u0172\3\2\2\2\2\u0174\3\2\2\2\2\u0176\3\2\2") + buf.write("\2\2\u0178\3\2\2\2\2\u017a\3\2\2\2\2\u017c\3\2\2\2\2\u017e") + buf.write("\3\2\2\2\2\u0180\3\2\2\2\2\u0182\3\2\2\2\2\u0184\3\2\2") + buf.write("\2\2\u0186\3\2\2\2\2\u0188\3\2\2\2\2\u018a\3\2\2\2\2\u018c") + buf.write("\3\2\2\2\2\u018e\3\2\2\2\2\u0190\3\2\2\2\2\u0192\3\2\2") + buf.write("\2\2\u0194\3\2\2\2\2\u0196\3\2\2\2\2\u0198\3\2\2\2\2\u019a") + buf.write("\3\2\2\2\2\u019c\3\2\2\2\2\u019e\3\2\2\2\2\u01a0\3\2\2") + buf.write("\2\2\u01a2\3\2\2\2\2\u01a4\3\2\2\2\2\u01a6\3\2\2\2\2\u01a8") + buf.write("\3\2\2\2\2\u01aa\3\2\2\2\2\u01ac\3\2\2\2\2\u01ae\3\2\2") + buf.write("\2\2\u01b0\3\2\2\2\2\u01b2\3\2\2\2\2\u01b4\3\2\2\2\2\u01b6") + buf.write("\3\2\2\2\2\u01b8\3\2\2\2\2\u01ba\3\2\2\2\2\u01bc\3\2\2") + buf.write("\2\2\u01be\3\2\2\2\2\u01c0\3\2\2\2\2\u01c2\3\2\2\2\2\u01c4") + buf.write("\3\2\2\2\2\u01c6\3\2\2\2\2\u01c8\3\2\2\2\2\u01ca\3\2\2") + buf.write("\2\2\u01cc\3\2\2\2\2\u01ce\3\2\2\2\2\u01d0\3\2\2\2\2\u01d2") + buf.write("\3\2\2\2\2\u01d4\3\2\2\2\2\u01d6\3\2\2\2\2\u01d8\3\2\2") + buf.write("\2\2\u01da\3\2\2\2\2\u01dc\3\2\2\2\2\u01de\3\2\2\2\2\u01e0") + buf.write("\3\2\2\2\2\u01e2\3\2\2\2\2\u01e4\3\2\2\2\2\u01e6\3\2\2") + buf.write("\2\2\u01e8\3\2\2\2\2\u01ea\3\2\2\2\2\u01ec\3\2\2\2\2\u01ee") + buf.write("\3\2\2\2\2\u01f0\3\2\2\2\2\u01f2\3\2\2\2\2\u01f4\3\2\2") + buf.write("\2\2\u01f6\3\2\2\2\2\u01f8\3\2\2\2\2\u01fa\3\2\2\2\2\u01fc") + buf.write("\3\2\2\2\2\u01fe\3\2\2\2\2\u0200\3\2\2\2\2\u0202\3\2\2") + buf.write("\2\2\u0204\3\2\2\2\2\u0206\3\2\2\2\2\u0208\3\2\2\2\2\u020a") + buf.write("\3\2\2\2\2\u020c\3\2\2\2\2\u020e\3\2\2\2\2\u0210\3\2\2") + buf.write("\2\2\u0212\3\2\2\2\2\u0214\3\2\2\2\2\u0216\3\2\2\2\2\u0218") + buf.write("\3\2\2\2\2\u021a\3\2\2\2\2\u021c\3\2\2\2\2\u021e\3\2\2") + buf.write("\2\2\u0220\3\2\2\2\2\u0222\3\2\2\2\2\u0224\3\2\2\2\2\u0226") + buf.write("\3\2\2\2\2\u0228\3\2\2\2\2\u022a\3\2\2\2\2\u022c\3\2\2") + buf.write("\2\2\u022e\3\2\2\2\2\u0230\3\2\2\2\2\u0232\3\2\2\2\2\u0234") + buf.write("\3\2\2\2\2\u0236\3\2\2\2\2\u0238\3\2\2\2\2\u023a\3\2\2") + buf.write("\2\2\u023c\3\2\2\2\2\u023e\3\2\2\2\2\u0240\3\2\2\2\2\u0242") + buf.write("\3\2\2\2\2\u0244\3\2\2\2\2\u0246\3\2\2\2\2\u0248\3\2\2") + buf.write("\2\2\u024a\3\2\2\2\2\u024c\3\2\2\2\2\u024e\3\2\2\2\2\u0250") + buf.write("\3\2\2\2\2\u0252\3\2\2\2\2\u0254\3\2\2\2\2\u0256\3\2\2") + buf.write("\2\2\u0258\3\2\2\2\2\u025a\3\2\2\2\2\u025c\3\2\2\2\2\u025e") + buf.write("\3\2\2\2\2\u0260\3\2\2\2\2\u0262\3\2\2\2\2\u0264\3\2\2") + buf.write("\2\2\u0266\3\2\2\2\2\u0268\3\2\2\2\2\u026a\3\2\2\2\2\u026c") + buf.write("\3\2\2\2\2\u026e\3\2\2\2\2\u0270\3\2\2\2\2\u0272\3\2\2") + buf.write("\2\2\u0274\3\2\2\2\2\u0276\3\2\2\2\2\u0278\3\2\2\2\2\u027a") + buf.write("\3\2\2\2\2\u027c\3\2\2\2\2\u027e\3\2\2\2\2\u0280\3\2\2") + buf.write("\2\2\u0282\3\2\2\2\2\u0284\3\2\2\2\2\u0286\3\2\2\2\2\u0288") + buf.write("\3\2\2\2\2\u028a\3\2\2\2\2\u028c\3\2\2\2\2\u028e\3\2\2") + buf.write("\2\2\u0290\3\2\2\2\2\u0292\3\2\2\2\2\u0294\3\2\2\2\2\u0296") + buf.write("\3\2\2\2\2\u0298\3\2\2\2\2\u029a\3\2\2\2\2\u029c\3\2\2") + buf.write("\2\2\u029e\3\2\2\2\2\u02a0\3\2\2\2\2\u02a2\3\2\2\2\2\u02a4") + buf.write("\3\2\2\2\2\u02a6\3\2\2\2\2\u02a8\3\2\2\2\2\u02aa\3\2\2") + buf.write("\2\2\u02ac\3\2\2\2\2\u02ae\3\2\2\2\2\u02b0\3\2\2\2\2\u02b2") + buf.write("\3\2\2\2\2\u02b4\3\2\2\2\2\u02b6\3\2\2\2\2\u02b8\3\2\2") + buf.write("\2\2\u02ba\3\2\2\2\2\u02bc\3\2\2\2\2\u02be\3\2\2\2\2\u02c0") + buf.write("\3\2\2\2\2\u02c2\3\2\2\2\2\u02c4\3\2\2\2\2\u02c6\3\2\2") + buf.write("\2\2\u02c8\3\2\2\2\2\u02ca\3\2\2\2\2\u02cc\3\2\2\2\2\u02ce") + buf.write("\3\2\2\2\2\u02d0\3\2\2\2\2\u02d2\3\2\2\2\2\u02d4\3\2\2") + buf.write("\2\2\u02d6\3\2\2\2\2\u02d8\3\2\2\2\2\u02da\3\2\2\2\2\u02dc") + buf.write("\3\2\2\2\2\u02de\3\2\2\2\2\u02e0\3\2\2\2\2\u02e2\3\2\2") + buf.write("\2\2\u02e4\3\2\2\2\2\u02e6\3\2\2\2\2\u02e8\3\2\2\2\2\u02ea") + buf.write("\3\2\2\2\2\u02ec\3\2\2\2\2\u02ee\3\2\2\2\2\u02f0\3\2\2") + buf.write("\2\2\u02f2\3\2\2\2\2\u02f4\3\2\2\2\2\u02f6\3\2\2\2\2\u02f8") + buf.write("\3\2\2\2\2\u02fa\3\2\2\2\2\u02fc\3\2\2\2\2\u02fe\3\2\2") + buf.write("\2\2\u0300\3\2\2\2\2\u0302\3\2\2\2\2\u0304\3\2\2\2\2\u0306") + buf.write("\3\2\2\2\2\u0308\3\2\2\2\2\u030a\3\2\2\2\2\u030c\3\2\2") + buf.write("\2\2\u030e\3\2\2\2\2\u0310\3\2\2\2\2\u0312\3\2\2\2\2\u0314") + buf.write("\3\2\2\2\2\u0316\3\2\2\2\2\u0318\3\2\2\2\2\u031a\3\2\2") + buf.write("\2\2\u031c\3\2\2\2\2\u031e\3\2\2\2\2\u0320\3\2\2\2\2\u0322") + buf.write("\3\2\2\2\2\u0324\3\2\2\2\2\u0326\3\2\2\2\2\u0328\3\2\2") + buf.write("\2\2\u032a\3\2\2\2\2\u032c\3\2\2\2\2\u032e\3\2\2\2\2\u0330") + buf.write("\3\2\2\2\2\u0332\3\2\2\2\2\u0334\3\2\2\2\2\u0336\3\2\2") + buf.write("\2\2\u0338\3\2\2\2\2\u033a\3\2\2\2\2\u033c\3\2\2\2\2\u033e") + buf.write("\3\2\2\2\2\u0340\3\2\2\2\2\u0342\3\2\2\2\2\u0344\3\2\2") + buf.write("\2\2\u0346\3\2\2\2\2\u0348\3\2\2\2\2\u034a\3\2\2\2\2\u034c") + buf.write("\3\2\2\2\2\u034e\3\2\2\2\2\u0350\3\2\2\2\2\u0352\3\2\2") + buf.write("\2\2\u0354\3\2\2\2\2\u0356\3\2\2\2\2\u0358\3\2\2\2\2\u035a") + buf.write("\3\2\2\2\2\u035c\3\2\2\2\2\u035e\3\2\2\2\2\u0360\3\2\2") + buf.write("\2\2\u0362\3\2\2\2\2\u0364\3\2\2\2\2\u0366\3\2\2\2\2\u0368") + buf.write("\3\2\2\2\2\u036a\3\2\2\2\2\u036c\3\2\2\2\2\u036e\3\2\2") + buf.write("\2\2\u0370\3\2\2\2\2\u0372\3\2\2\2\2\u0374\3\2\2\2\2\u0376") + buf.write("\3\2\2\2\2\u0378\3\2\2\2\2\u037a\3\2\2\2\2\u037c\3\2\2") + buf.write("\2\2\u037e\3\2\2\2\2\u0380\3\2\2\2\2\u0382\3\2\2\2\2\u0384") + buf.write("\3\2\2\2\2\u0386\3\2\2\2\2\u0388\3\2\2\2\2\u038a\3\2\2") + buf.write("\2\2\u038c\3\2\2\2\2\u038e\3\2\2\2\2\u0390\3\2\2\2\2\u0392") + buf.write("\3\2\2\2\2\u0394\3\2\2\2\2\u0396\3\2\2\2\2\u0398\3\2\2") + buf.write("\2\2\u039a\3\2\2\2\2\u039c\3\2\2\2\2\u039e\3\2\2\2\2\u03a0") + buf.write("\3\2\2\2\2\u03a2\3\2\2\2\2\u03a4\3\2\2\2\2\u03a6\3\2\2") + buf.write("\2\2\u03a8\3\2\2\2\2\u03aa\3\2\2\2\2\u03ac\3\2\2\2\2\u03ae") + buf.write("\3\2\2\2\2\u03b0\3\2\2\2\2\u03b2\3\2\2\2\2\u03b4\3\2\2") + buf.write("\2\2\u03b6\3\2\2\2\2\u03b8\3\2\2\2\2\u03ba\3\2\2\2\2\u03bc") + buf.write("\3\2\2\2\2\u03be\3\2\2\2\2\u03c0\3\2\2\2\2\u03c2\3\2\2") + buf.write("\2\2\u03c4\3\2\2\2\2\u03c6\3\2\2\2\2\u03c8\3\2\2\2\2\u03ca") + buf.write("\3\2\2\2\2\u03cc\3\2\2\2\2\u03ce\3\2\2\2\2\u03d0\3\2\2") + buf.write("\2\2\u03d2\3\2\2\2\2\u03d4\3\2\2\2\2\u03d6\3\2\2\2\2\u03d8") + buf.write("\3\2\2\2\2\u03da\3\2\2\2\2\u03dc\3\2\2\2\2\u03de\3\2\2") + buf.write("\2\2\u03e0\3\2\2\2\2\u03e2\3\2\2\2\2\u03e4\3\2\2\2\2\u03e6") + buf.write("\3\2\2\2\2\u03e8\3\2\2\2\2\u03ea\3\2\2\2\2\u03ec\3\2\2") + buf.write("\2\2\u03ee\3\2\2\2\2\u03f0\3\2\2\2\2\u03f2\3\2\2\2\2\u03f4") + buf.write("\3\2\2\2\2\u03f6\3\2\2\2\2\u03f8\3\2\2\2\2\u03fa\3\2\2") + buf.write("\2\2\u03fc\3\2\2\2\2\u03fe\3\2\2\2\2\u0400\3\2\2\2\2\u0402") + buf.write("\3\2\2\2\2\u0404\3\2\2\2\2\u0406\3\2\2\2\2\u0408\3\2\2") + buf.write("\2\2\u040a\3\2\2\2\2\u040c\3\2\2\2\2\u040e\3\2\2\2\2\u0410") + buf.write("\3\2\2\2\2\u0412\3\2\2\2\2\u0414\3\2\2\2\2\u0416\3\2\2") + buf.write("\2\2\u0418\3\2\2\2\2\u041a\3\2\2\2\2\u041c\3\2\2\2\2\u041e") + buf.write("\3\2\2\2\2\u0420\3\2\2\2\2\u0422\3\2\2\2\2\u0424\3\2\2") + buf.write("\2\2\u0426\3\2\2\2\2\u0428\3\2\2\2\2\u042a\3\2\2\2\2\u042c") + buf.write("\3\2\2\2\2\u042e\3\2\2\2\2\u0430\3\2\2\2\2\u0432\3\2\2") + buf.write("\2\2\u0434\3\2\2\2\2\u0436\3\2\2\2\2\u0438\3\2\2\2\2\u043a") + buf.write("\3\2\2\2\2\u043c\3\2\2\2\2\u043e\3\2\2\2\2\u0440\3\2\2") + buf.write("\2\2\u0442\3\2\2\2\2\u0444\3\2\2\2\2\u0446\3\2\2\2\2\u0448") + buf.write("\3\2\2\2\2\u044a\3\2\2\2\2\u044c\3\2\2\2\2\u044e\3\2\2") + buf.write("\2\2\u0450\3\2\2\2\2\u0452\3\2\2\2\2\u0454\3\2\2\2\2\u0456") + buf.write("\3\2\2\2\2\u0458\3\2\2\2\2\u045a\3\2\2\2\2\u045c\3\2\2") + buf.write("\2\2\u045e\3\2\2\2\2\u0460\3\2\2\2\2\u0462\3\2\2\2\2\u0464") + buf.write("\3\2\2\2\2\u0466\3\2\2\2\2\u0468\3\2\2\2\2\u046a\3\2\2") + buf.write("\2\2\u046c\3\2\2\2\2\u046e\3\2\2\2\2\u0470\3\2\2\2\2\u0472") + buf.write("\3\2\2\2\2\u0474\3\2\2\2\2\u0476\3\2\2\2\2\u0478\3\2\2") + buf.write("\2\2\u047a\3\2\2\2\2\u047c\3\2\2\2\2\u047e\3\2\2\2\2\u0482") + buf.write("\3\2\2\2\2\u0484\3\2\2\2\2\u0486\3\2\2\2\2\u0488\3\2\2") + buf.write("\2\2\u048a\3\2\2\2\2\u048c\3\2\2\2\2\u048e\3\2\2\2\2\u0490") + buf.write("\3\2\2\2\2\u0492\3\2\2\2\2\u0494\3\2\2\2\2\u0496\3\2\2") + buf.write("\2\2\u0498\3\2\2\2\2\u049a\3\2\2\2\2\u049c\3\2\2\2\2\u049e") + buf.write("\3\2\2\2\2\u04a0\3\2\2\2\2\u04a2\3\2\2\2\2\u04a4\3\2\2") + buf.write("\2\2\u04a6\3\2\2\2\2\u04a8\3\2\2\2\2\u04aa\3\2\2\2\2\u04ac") + buf.write("\3\2\2\2\2\u04ae\3\2\2\2\2\u04b0\3\2\2\2\2\u04b2\3\2\2") + buf.write("\2\2\u04b4\3\2\2\2\2\u04b6\3\2\2\2\2\u04b8\3\2\2\2\2\u04ba") + buf.write("\3\2\2\2\2\u04bc\3\2\2\2\2\u04be\3\2\2\2\2\u04c0\3\2\2") + buf.write("\2\2\u04c2\3\2\2\2\2\u04ca\3\2\2\2\2\u04ce\3\2\2\2\2\u04d0") + buf.write("\3\2\2\2\2\u04d2\3\2\2\2\2\u04da\3\2\2\2\2\u04e2\3\2\2") + buf.write("\2\2\u04ea\3\2\2\2\2\u04ee\3\2\2\2\2\u04f0\3\2\2\2\2\u04f2") + buf.write("\3\2\2\2\2\u04f4\3\2\2\2\2\u04f6\3\2\2\2\2\u04f8\3\2\2") + buf.write("\2\3\u04fa\3\2\2\2\3\u04fc\3\2\2\2\4\u04fe\3\2\2\2\6\u0504") + buf.write("\3\2\2\2\b\u050d\3\2\2\2\n\u0514\3\2\2\2\f\u051b\3\2\2") + buf.write("\2\16\u051f\3\2\2\2\20\u0525\3\2\2\2\22\u052b\3\2\2\2") + buf.write("\24\u0535\3\2\2\2\26\u053a\3\2\2\2\30\u0540\3\2\2\2\32") + buf.write("\u0547\3\2\2\2\34\u0551\3\2\2\2\36\u055c\3\2\2\2 \u055f") + buf.write("\3\2\2\2\"\u0566\3\2\2\2$\u0570\3\2\2\2&\u0579\3\2\2\2") + buf.write("(\u0580\3\2\2\2*\u0586\3\2\2\2,\u0589\3\2\2\2.\u058f\3") + buf.write("\2\2\2\60\u0594\3\2\2\2\62\u059b\3\2\2\2\64\u05a3\3\2") + buf.write("\2\2\66\u05ac\3\2\2\28\u05b4\3\2\2\2:\u05ba\3\2\2\2<\u05ca") + buf.write("\3\2\2\2>\u05d5\3\2\2\2@\u05db\3\2\2\2B\u05e1\3\2\2\2") + buf.write("D\u05e9\3\2\2\2F\u05f1\3\2\2\2H\u05f9\3\2\2\2J\u0602\3") + buf.write("\2\2\2L\u0609\3\2\2\2N\u0613\3\2\2\2P\u0621\3\2\2\2R\u062a") + buf.write("\3\2\2\2T\u0635\3\2\2\2V\u0641\3\2\2\2X\u0649\3\2\2\2") + buf.write("Z\u0652\3\2\2\2\\\u065d\3\2\2\2^\u0662\3\2\2\2`\u0667") + buf.write("\3\2\2\2b\u066b\3\2\2\2d\u0670\3\2\2\2f\u0678\3\2\2\2") + buf.write("h\u067f\3\2\2\2j\u0685\3\2\2\2l\u068a\3\2\2\2n\u0693\3") + buf.write("\2\2\2p\u0697\3\2\2\2r\u06a2\3\2\2\2t\u06aa\3\2\2\2v\u06b3") + buf.write("\3\2\2\2x\u06bc\3\2\2\2z\u06c4\3\2\2\2|\u06cb\3\2\2\2") + buf.write("~\u06d5\3\2\2\2\u0080\u06e0\3\2\2\2\u0082\u06e8\3\2\2") + buf.write("\2\u0084\u06ef\3\2\2\2\u0086\u06fa\3\2\2\2\u0088\u0702") + buf.write("\3\2\2\2\u008a\u070a\3\2\2\2\u008c\u0713\3\2\2\2\u008e") + buf.write("\u071a\3\2\2\2\u0090\u0721\3\2\2\2\u0092\u0726\3\2\2\2") + buf.write("\u0094\u072b\3\2\2\2\u0096\u0732\3\2\2\2\u0098\u073b\3") + buf.write("\2\2\2\u009a\u0745\3\2\2\2\u009c\u074a\3\2\2\2\u009e\u0751") + buf.write("\3\2\2\2\u00a0\u0757\3\2\2\2\u00a2\u075f\3\2\2\2\u00a4") + buf.write("\u0769\3\2\2\2\u00a6\u0773\3\2\2\2\u00a8\u077b\3\2\2\2") + buf.write("\u00aa\u0783\3\2\2\2\u00ac\u078d\3\2\2\2\u00ae\u0796\3") + buf.write("\2\2\2\u00b0\u079d\3\2\2\2\u00b2\u07a4\3\2\2\2\u00b4\u07aa") + buf.write("\3\2\2\2\u00b6\u07b4\3\2\2\2\u00b8\u07ba\3\2\2\2\u00ba") + buf.write("\u07c2\3\2\2\2\u00bc\u07cb\3\2\2\2\u00be\u07d5\3\2\2\2") + buf.write("\u00c0\u07df\3\2\2\2\u00c2\u07e6\3\2\2\2\u00c4\u07ee\3") + buf.write("\2\2\2\u00c6\u07f5\3\2\2\2\u00c8\u07fd\3\2\2\2\u00ca\u0804") + buf.write("\3\2\2\2\u00cc\u0809\3\2\2\2\u00ce\u080e\3\2\2\2\u00d0") + buf.write("\u0817\3\2\2\2\u00d2\u081a\3\2\2\2\u00d4\u0824\3\2\2\2") + buf.write("\u00d6\u082e\3\2\2\2\u00d8\u0837\3\2\2\2\u00da\u083e\3") + buf.write("\2\2\2\u00dc\u0846\3\2\2\2\u00de\u0850\3\2\2\2\u00e0\u085a") + buf.write("\3\2\2\2\u00e2\u0860\3\2\2\2\u00e4\u0868\3\2\2\2\u00e6") + buf.write("\u0870\3\2\2\2\u00e8\u0879\3\2\2\2\u00ea\u0880\3\2\2\2") + buf.write("\u00ec\u0886\3\2\2\2\u00ee\u0892\3\2\2\2\u00f0\u0899\3") + buf.write("\2\2\2\u00f2\u08a1\3\2\2\2\u00f4\u08a9\3\2\2\2\u00f6\u08b3") + buf.write("\3\2\2\2\u00f8\u08b7\3\2\2\2\u00fa\u08bd\3\2\2\2\u00fc") + buf.write("\u08c6\3\2\2\2\u00fe\u08cc\3\2\2\2\u0100\u08d1\3\2\2\2") + buf.write("\u0102\u08db\3\2\2\2\u0104\u08e1\3\2\2\2\u0106\u08e8\3") + buf.write("\2\2\2\u0108\u08ed\3\2\2\2\u010a\u08f3\3\2\2\2\u010c\u08fc") + buf.write("\3\2\2\2\u010e\u0901\3\2\2\2\u0110\u0908\3\2\2\2\u0112") + buf.write("\u090f\3\2\2\2\u0114\u0917\3\2\2\2\u0116\u091d\3\2\2\2") + buf.write("\u0118\u092a\3\2\2\2\u011a\u0933\3\2\2\2\u011c\u093a\3") + buf.write("\2\2\2\u011e\u0941\3\2\2\2\u0120\u094a\3\2\2\2\u0122\u094f") + buf.write("\3\2\2\2\u0124\u0955\3\2\2\2\u0126\u095a\3\2\2\2\u0128") + buf.write("\u095f\3\2\2\2\u012a\u0965\3\2\2\2\u012c\u0969\3\2\2\2") + buf.write("\u012e\u096e\3\2\2\2\u0130\u0971\3\2\2\2\u0132\u0979\3") + buf.write("\2\2\2\u0134\u0980\3\2\2\2\u0136\u0987\3\2\2\2\u0138\u098d") + buf.write("\3\2\2\2\u013a\u0994\3\2\2\2\u013c\u0997\3\2\2\2\u013e") + buf.write("\u099b\3\2\2\2\u0140\u09a0\3\2\2\2\u0142\u09a4\3\2\2\2") + buf.write("\u0144\u09ad\3\2\2\2\u0146\u09b4\3\2\2\2\u0148\u09bc\3") + buf.write("\2\2\2\u014a\u09c7\3\2\2\2\u014c\u09ce\3\2\2\2\u014e\u09d3") + buf.write("\3\2\2\2\u0150\u09de\3\2\2\2\u0152\u09e4\3\2\2\2\u0154") + buf.write("\u09ea\3\2\2\2\u0156\u09f3\3\2\2\2\u0158\u09fa\3\2\2\2") + buf.write("\u015a\u0a02\3\2\2\2\u015c\u0a0c\3\2\2\2\u015e\u0a14\3") + buf.write("\2\2\2\u0160\u0a1d\3\2\2\2\u0162\u0a23\3\2\2\2\u0164\u0a2a") + buf.write("\3\2\2\2\u0166\u0a34\3\2\2\2\u0168\u0a3c\3\2\2\2\u016a") + buf.write("\u0a45\3\2\2\2\u016c\u0a4e\3\2\2\2\u016e\u0a54\3\2\2\2") + buf.write("\u0170\u0a5f\3\2\2\2\u0172\u0a6a\3\2\2\2\u0174\u0a74\3") + buf.write("\2\2\2\u0176\u0a7f\3\2\2\2\u0178\u0a87\3\2\2\2\u017a\u0a93") + buf.write("\3\2\2\2\u017c\u0a99\3\2\2\2\u017e\u0a9f\3\2\2\2\u0180") + buf.write("\u0aa4\3\2\2\2\u0182\u0aad\3\2\2\2\u0184\u0ab5\3\2\2\2") + buf.write("\u0186\u0abf\3\2\2\2\u0188\u0ac3\3\2\2\2\u018a\u0acf\3") + buf.write("\2\2\2\u018c\u0ad7\3\2\2\2\u018e\u0adf\3\2\2\2\u0190\u0ae8") + buf.write("\3\2\2\2\u0192\u0af0\3\2\2\2\u0194\u0af7\3\2\2\2\u0196") + buf.write("\u0b02\3\2\2\2\u0198\u0b0a\3\2\2\2\u019a\u0b12\3\2\2\2") + buf.write("\u019c\u0b18\3\2\2\2\u019e\u0b20\3\2\2\2\u01a0\u0b29\3") + buf.write("\2\2\2\u01a2\u0b31\3\2\2\2\u01a4\u0b38\3\2\2\2\u01a6\u0b3d") + buf.write("\3\2\2\2\u01a8\u0b46\3\2\2\2\u01aa\u0b4d\3\2\2\2\u01ac") + buf.write("\u0b55\3\2\2\2\u01ae\u0b5e\3\2\2\2\u01b0\u0b63\3\2\2\2") + buf.write("\u01b2\u0b68\3\2\2\2\u01b4\u0b72\3\2\2\2\u01b6\u0b79\3") + buf.write("\2\2\2\u01b8\u0b81\3\2\2\2\u01ba\u0b88\3\2\2\2\u01bc\u0b8f") + buf.write("\3\2\2\2\u01be\u0b96\3\2\2\2\u01c0\u0b9f\3\2\2\2\u01c2") + buf.write("\u0ba8\3\2\2\2\u01c4\u0bb2\3\2\2\2\u01c6\u0bbf\3\2\2\2") + buf.write("\u01c8\u0bc6\3\2\2\2\u01ca\u0bce\3\2\2\2\u01cc\u0bd2\3") + buf.write("\2\2\2\u01ce\u0bd7\3\2\2\2\u01d0\u0bdd\3\2\2\2\u01d2\u0be2") + buf.write("\3\2\2\2\u01d4\u0be9\3\2\2\2\u01d6\u0bee\3\2\2\2\u01d8") + buf.write("\u0bf7\3\2\2\2\u01da\u0bfb\3\2\2\2\u01dc\u0c02\3\2\2\2") + buf.write("\u01de\u0c0d\3\2\2\2\u01e0\u0c13\3\2\2\2\u01e2\u0c1d\3") + buf.write("\2\2\2\u01e4\u0c28\3\2\2\2\u01e6\u0c2e\3\2\2\2\u01e8\u0c35") + buf.write("\3\2\2\2\u01ea\u0c3d\3\2\2\2\u01ec\u0c44\3\2\2\2\u01ee") + buf.write("\u0c4b\3\2\2\2\u01f0\u0c51\3\2\2\2\u01f2\u0c5e\3\2\2\2") + buf.write("\u01f4\u0c66\3\2\2\2\u01f6\u0c6c\3\2\2\2\u01f8\u0c73\3") + buf.write("\2\2\2\u01fa\u0c7a\3\2\2\2\u01fc\u0c85\3\2\2\2\u01fe\u0c8a") + buf.write("\3\2\2\2\u0200\u0c93\3\2\2\2\u0202\u0c9d\3\2\2\2\u0204") + buf.write("\u0ca2\3\2\2\2\u0206\u0ca7\3\2\2\2\u0208\u0cb3\3\2\2\2") + buf.write("\u020a\u0cbd\3\2\2\2\u020c\u0cc5\3\2\2\2\u020e\u0cce\3") + buf.write("\2\2\2\u0210\u0cd6\3\2\2\2\u0212\u0cdb\3\2\2\2\u0214\u0ce1") + buf.write("\3\2\2\2\u0216\u0ceb\3\2\2\2\u0218\u0cf7\3\2\2\2\u021a") + buf.write("\u0d03\3\2\2\2\u021c\u0d0b\3\2\2\2\u021e\u0d14\3\2\2\2") + buf.write("\u0220\u0d1d\3\2\2\2\u0222\u0d23\3\2\2\2\u0224\u0d2a\3") + buf.write("\2\2\2\u0226\u0d31\3\2\2\2\u0228\u0d37\3\2\2\2\u022a\u0d40") + buf.write("\3\2\2\2\u022c\u0d4a\3\2\2\2\u022e\u0d50\3\2\2\2\u0230") + buf.write("\u0d58\3\2\2\2\u0232\u0d60\3\2\2\2\u0234\u0d65\3\2\2\2") + buf.write("\u0236\u0d6b\3\2\2\2\u0238\u0d74\3\2\2\2\u023a\u0d7f\3") + buf.write("\2\2\2\u023c\u0d86\3\2\2\2\u023e\u0d8e\3\2\2\2\u0240\u0d93") + buf.write("\3\2\2\2\u0242\u0d9b\3\2\2\2\u0244\u0da1\3\2\2\2\u0246") + buf.write("\u0da5\3\2\2\2\u0248\u0daa\3\2\2\2\u024a\u0dae\3\2\2\2") + buf.write("\u024c\u0db3\3\2\2\2\u024e\u0dbb\3\2\2\2\u0250\u0dc2\3") + buf.write("\2\2\2\u0252\u0dc6\3\2\2\2\u0254\u0dce\3\2\2\2\u0256\u0dd3") + buf.write("\3\2\2\2\u0258\u0ddd\3\2\2\2\u025a\u0de6\3\2\2\2\u025c") + buf.write("\u0dea\3\2\2\2\u025e\u0df2\3\2\2\2\u0260\u0df9\3\2\2\2") + buf.write("\u0262\u0e01\3\2\2\2\u0264\u0e07\3\2\2\2\u0266\u0e10\3") + buf.write("\2\2\2\u0268\u0e19\3\2\2\2\u026a\u0e1f\3\2\2\2\u026c\u0e23") + buf.write("\3\2\2\2\u026e\u0e2b\3\2\2\2\u0270\u0e34\3\2\2\2\u0272") + buf.write("\u0e3a\3\2\2\2\u0274\u0e43\3\2\2\2\u0276\u0e49\3\2\2\2") + buf.write("\u0278\u0e4e\3\2\2\2\u027a\u0e55\3\2\2\2\u027c\u0e5d\3") + buf.write("\2\2\2\u027e\u0e61\3\2\2\2\u0280\u0e69\3\2\2\2\u0282\u0e72") + buf.write("\3\2\2\2\u0284\u0e7c\3\2\2\2\u0286\u0e81\3\2\2\2\u0288") + buf.write("\u0e85\3\2\2\2\u028a\u0e8b\3\2\2\2\u028c\u0e94\3\2\2\2") + buf.write("\u028e\u0e9e\3\2\2\2\u0290\u0ea3\3\2\2\2\u0292\u0ead\3") + buf.write("\2\2\2\u0294\u0eb3\3\2\2\2\u0296\u0eb8\3\2\2\2\u0298\u0ebf") + buf.write("\3\2\2\2\u029a\u0ec7\3\2\2\2\u029c\u0ed5\3\2\2\2\u029e") + buf.write("\u0edf\3\2\2\2\u02a0\u0eea\3\2\2\2\u02a2\u0ef4\3\2\2\2") + buf.write("\u02a4\u0efe\3\2\2\2\u02a6\u0f0c\3\2\2\2\u02a8\u0f15\3") + buf.write("\2\2\2\u02aa\u0f1b\3\2\2\2\u02ac\u0f23\3\2\2\2\u02ae\u0f30") + buf.write("\3\2\2\2\u02b0\u0f39\3\2\2\2\u02b2\u0f47\3\2\2\2\u02b4") + buf.write("\u0f4e\3\2\2\2\u02b6\u0f58\3\2\2\2\u02b8\u0f65\3\2\2\2") + buf.write("\u02ba\u0f6b\3\2\2\2\u02bc\u0f7a\3\2\2\2\u02be\u0f81\3") + buf.write("\2\2\2\u02c0\u0f86\3\2\2\2\u02c2\u0f8c\3\2\2\2\u02c4\u0f92") + buf.write("\3\2\2\2\u02c6\u0f95\3\2\2\2\u02c8\u0f9c\3\2\2\2\u02ca") + buf.write("\u0fa1\3\2\2\2\u02cc\u0fa6\3\2\2\2\u02ce\u0fab\3\2\2\2") + buf.write("\u02d0\u0fb3\3\2\2\2\u02d2\u0fbb\3\2\2\2\u02d4\u0fc1\3") + buf.write("\2\2\2\u02d6\u0fca\3\2\2\2\u02d8\u0fd0\3\2\2\2\u02da\u0fd8") + buf.write("\3\2\2\2\u02dc\u0fe4\3\2\2\2\u02de\u0fec\3\2\2\2\u02e0") + buf.write("\u0ff0\3\2\2\2\u02e2\u0ff8\3\2\2\2\u02e4\u1000\3\2\2\2") + buf.write("\u02e6\u1004\3\2\2\2\u02e8\u1008\3\2\2\2\u02ea\u100e\3") + buf.write("\2\2\2\u02ec\u1011\3\2\2\2\u02ee\u1015\3\2\2\2\u02f0\u1020") + buf.write("\3\2\2\2\u02f2\u1025\3\2\2\2\u02f4\u102a\3\2\2\2\u02f6") + buf.write("\u102f\3\2\2\2\u02f8\u1035\3\2\2\2\u02fa\u103d\3\2\2\2") + buf.write("\u02fc\u1044\3\2\2\2\u02fe\u104f\3\2\2\2\u0300\u1056\3") + buf.write("\2\2\2\u0302\u1066\3\2\2\2\u0304\u1073\3\2\2\2\u0306\u1080") + buf.write("\3\2\2\2\u0308\u108d\3\2\2\2\u030a\u109f\3\2\2\2\u030c") + buf.write("\u10ac\3\2\2\2\u030e\u10b4\3\2\2\2\u0310\u10bf\3\2\2\2") + buf.write("\u0312\u10c4\3\2\2\2\u0314\u10cd\3\2\2\2\u0316\u10d0\3") + buf.write("\2\2\2\u0318\u10d5\3\2\2\2\u031a\u10d9\3\2\2\2\u031c\u10e0") + buf.write("\3\2\2\2\u031e\u10e6\3\2\2\2\u0320\u10ec\3\2\2\2\u0322") + buf.write("\u10f0\3\2\2\2\u0324\u10f8\3\2\2\2\u0326\u10fd\3\2\2\2") + buf.write("\u0328\u1103\3\2\2\2\u032a\u1109\3\2\2\2\u032c\u1110\3") + buf.write("\2\2\2\u032e\u1113\3\2\2\2\u0330\u111d\3\2\2\2\u0332\u1127") + buf.write("\3\2\2\2\u0334\u112c\3\2\2\2\u0336\u1134\3\2\2\2\u0338") + buf.write("\u113c\3\2\2\2\u033a\u1142\3\2\2\2\u033c\u114c\3\2\2\2") + buf.write("\u033e\u115b\3\2\2\2\u0340\u115f\3\2\2\2\u0342\u1164\3") + buf.write("\2\2\2\u0344\u116b\3\2\2\2\u0346\u116e\3\2\2\2\u0348\u1173") + buf.write("\3\2\2\2\u034a\u1176\3\2\2\2\u034c\u117c\3\2\2\2\u034e") + buf.write("\u1184\3\2\2\2\u0350\u118c\3\2\2\2\u0352\u1197\3\2\2\2") + buf.write("\u0354\u11a1\3\2\2\2\u0356\u11a8\3\2\2\2\u0358\u11b5\3") + buf.write("\2\2\2\u035a\u11ba\3\2\2\2\u035c\u11c4\3\2\2\2\u035e\u11ca") + buf.write("\3\2\2\2\u0360\u11cf\3\2\2\2\u0362\u11d2\3\2\2\2\u0364") + buf.write("\u11db\3\2\2\2\u0366\u11e0\3\2\2\2\u0368\u11e6\3\2\2\2") + buf.write("\u036a\u11ed\3\2\2\2\u036c\u11f2\3\2\2\2\u036e\u11f8\3") + buf.write("\2\2\2\u0370\u1201\3\2\2\2\u0372\u1206\3\2\2\2\u0374\u120c") + buf.write("\3\2\2\2\u0376\u1213\3\2\2\2\u0378\u1218\3\2\2\2\u037a") + buf.write("\u1222\3\2\2\2\u037c\u122b\3\2\2\2\u037e\u1233\3\2\2\2") + buf.write("\u0380\u123d\3\2\2\2\u0382\u1247\3\2\2\2\u0384\u1250\3") + buf.write("\2\2\2\u0386\u125b\3\2\2\2\u0388\u1267\3\2\2\2\u038a\u1272") + buf.write("\3\2\2\2\u038c\u127a\3\2\2\2\u038e\u1280\3\2\2\2\u0390") + buf.write("\u1289\3\2\2\2\u0392\u1294\3\2\2\2\u0394\u12a1\3\2\2\2") + buf.write("\u0396\u12af\3\2\2\2\u0398\u12bf\3\2\2\2\u039a\u12c7\3") + buf.write("\2\2\2\u039c\u12d0\3\2\2\2\u039e\u12da\3\2\2\2\u03a0\u12e2") + buf.write("\3\2\2\2\u03a2\u12eb\3\2\2\2\u03a4\u12fa\3\2\2\2\u03a6") + buf.write("\u1305\3\2\2\2\u03a8\u1311\3\2\2\2\u03aa\u1318\3\2\2\2") + buf.write("\u03ac\u1321\3\2\2\2\u03ae\u1326\3\2\2\2\u03b0\u132d\3") + buf.write("\2\2\2\u03b2\u1336\3\2\2\2\u03b4\u1343\3\2\2\2\u03b6\u1351") + buf.write("\3\2\2\2\u03b8\u1356\3\2\2\2\u03ba\u135f\3\2\2\2\u03bc") + buf.write("\u136e\3\2\2\2\u03be\u1373\3\2\2\2\u03c0\u137e\3\2\2\2") + buf.write("\u03c2\u1387\3\2\2\2\u03c4\u138f\3\2\2\2\u03c6\u1396\3") + buf.write("\2\2\2\u03c8\u139f\3\2\2\2\u03ca\u13a4\3\2\2\2\u03cc\u13ab") + buf.write("\3\2\2\2\u03ce\u13b1\3\2\2\2\u03d0\u13b6\3\2\2\2\u03d2") + buf.write("\u13bd\3\2\2\2\u03d4\u13c8\3\2\2\2\u03d6\u13d0\3\2\2\2") + buf.write("\u03d8\u13d9\3\2\2\2\u03da\u13e3\3\2\2\2\u03dc\u13ec\3") + buf.write("\2\2\2\u03de\u13f4\3\2\2\2\u03e0\u13fb\3\2\2\2\u03e2\u1403") + buf.write("\3\2\2\2\u03e4\u140a\3\2\2\2\u03e6\u1412\3\2\2\2\u03e8") + buf.write("\u141e\3\2\2\2\u03ea\u1429\3\2\2\2\u03ec\u1436\3\2\2\2") + buf.write("\u03ee\u1440\3\2\2\2\u03f0\u1448\3\2\2\2\u03f2\u1456\3") + buf.write("\2\2\2\u03f4\u1462\3\2\2\2\u03f6\u1469\3\2\2\2\u03f8\u1477") + buf.write("\3\2\2\2\u03fa\u147c\3\2\2\2\u03fc\u1487\3\2\2\2\u03fe") + buf.write("\u148d\3\2\2\2\u0400\u1497\3\2\2\2\u0402\u14a0\3\2\2\2") + buf.write("\u0404\u14a4\3\2\2\2\u0406\u14a8\3\2\2\2\u0408\u14b0\3") + buf.write("\2\2\2\u040a\u14ba\3\2\2\2\u040c\u14c6\3\2\2\2\u040e\u14d1") + buf.write("\3\2\2\2\u0410\u14dd\3\2\2\2\u0412\u14e6\3\2\2\2\u0414") + buf.write("\u14eb\3\2\2\2\u0416\u14f0\3\2\2\2\u0418\u14fb\3\2\2\2") + buf.write("\u041a\u1504\3\2\2\2\u041c\u150a\3\2\2\2\u041e\u1514\3") + buf.write("\2\2\2\u0420\u1520\3\2\2\2\u0422\u1527\3\2\2\2\u0424\u152e") + buf.write("\3\2\2\2\u0426\u1534\3\2\2\2\u0428\u1541\3\2\2\2\u042a") + buf.write("\u1551\3\2\2\2\u042c\u1559\3\2\2\2\u042e\u1561\3\2\2\2") + buf.write("\u0430\u156b\3\2\2\2\u0432\u1572\3\2\2\2\u0434\u157c\3") + buf.write("\2\2\2\u0436\u1587\3\2\2\2\u0438\u158e\3\2\2\2\u043a\u1594") + buf.write("\3\2\2\2\u043c\u159d\3\2\2\2\u043e\u15a2\3\2\2\2\u0440") + buf.write("\u15a8\3\2\2\2\u0442\u15af\3\2\2\2\u0444\u15b8\3\2\2\2") + buf.write("\u0446\u15c1\3\2\2\2\u0448\u15c7\3\2\2\2\u044a\u15ce\3") + buf.write("\2\2\2\u044c\u15da\3\2\2\2\u044e\u15e1\3\2\2\2\u0450\u15e7") + buf.write("\3\2\2\2\u0452\u15ef\3\2\2\2\u0454\u15f4\3\2\2\2\u0456") + buf.write("\u15fe\3\2\2\2\u0458\u1606\3\2\2\2\u045a\u160a\3\2\2\2") + buf.write("\u045c\u160f\3\2\2\2\u045e\u1614\3\2\2\2\u0460\u1618\3") + buf.write("\2\2\2\u0462\u161d\3\2\2\2\u0464\u1625\3\2\2\2\u0466\u162c") + buf.write("\3\2\2\2\u0468\u1631\3\2\2\2\u046a\u1639\3\2\2\2\u046c") + buf.write("\u163f\3\2\2\2\u046e\u1645\3\2\2\2\u0470\u164c\3\2\2\2") + buf.write("\u0472\u1653\3\2\2\2\u0474\u165b\3\2\2\2\u0476\u1663\3") + buf.write("\2\2\2\u0478\u1669\3\2\2\2\u047a\u1672\3\2\2\2\u047c\u167a") + buf.write("\3\2\2\2\u047e\u1682\3\2\2\2\u0480\u1688\3\2\2\2\u0482") + buf.write("\u168a\3\2\2\2\u0484\u168d\3\2\2\2\u0486\u168f\3\2\2\2") + buf.write("\u0488\u1691\3\2\2\2\u048a\u1693\3\2\2\2\u048c\u1699\3") + buf.write("\2\2\2\u048e\u169b\3\2\2\2\u0490\u169d\3\2\2\2\u0492\u16a0") + buf.write("\3\2\2\2\u0494\u16a2\3\2\2\2\u0496\u16a5\3\2\2\2\u0498") + buf.write("\u16a7\3\2\2\2\u049a\u16a9\3\2\2\2\u049c\u16ab\3\2\2\2") + buf.write("\u049e\u16ad\3\2\2\2\u04a0\u16af\3\2\2\2\u04a2\u16b1\3") + buf.write("\2\2\2\u04a4\u16b3\3\2\2\2\u04a6\u16b5\3\2\2\2\u04a8\u16b7") + buf.write("\3\2\2\2\u04aa\u16b9\3\2\2\2\u04ac\u16bb\3\2\2\2\u04ae") + buf.write("\u16bd\3\2\2\2\u04b0\u16bf\3\2\2\2\u04b2\u16c1\3\2\2\2") + buf.write("\u04b4\u16c4\3\2\2\2\u04b6\u16c7\3\2\2\2\u04b8\u16ca\3") + buf.write("\2\2\2\u04ba\u16cd\3\2\2\2\u04bc\u16d0\3\2\2\2\u04be\u16d2") + buf.write("\3\2\2\2\u04c0\u16e1\3\2\2\2\u04c2\u1702\3\2\2\2\u04c4") + buf.write("\u1709\3\2\2\2\u04c6\u170b\3\2\2\2\u04c8\u170d\3\2\2\2") + buf.write("\u04ca\u1710\3\2\2\2\u04cc\u1714\3\2\2\2\u04ce\u1744\3") + buf.write("\2\2\2\u04d0\u1746\3\2\2\2\u04d2\u1749\3\2\2\2\u04d4\u1758") + buf.write("\3\2\2\2\u04d6\u175c\3\2\2\2\u04d8\u1760\3\2\2\2\u04da") + buf.write("\u1762\3\2\2\2\u04dc\u1766\3\2\2\2\u04de\u176f\3\2\2\2") + buf.write("\u04e0\u1771\3\2\2\2\u04e2\u1774\3\2\2\2\u04e4\u177f\3") + buf.write("\2\2\2\u04e6\u1794\3\2\2\2\u04e8\u17a0\3\2\2\2\u04ea\u17a9") + buf.write("\3\2\2\2\u04ec\u17b2\3\2\2\2\u04ee\u17b9\3\2\2\2\u04f0") + buf.write("\u17bf\3\2\2\2\u04f2\u17ca\3\2\2\2\u04f4\u17ce\3\2\2\2") + buf.write("\u04f6\u17d2\3\2\2\2\u04f8\u17d4\3\2\2\2\u04fa\u17e2\3") + buf.write("\2\2\2\u04fc\u17e4\3\2\2\2\u04fe\u04ff\t\2\2\2\u04ff\u0500") + buf.write("\t\3\2\2\u0500\u0501\t\4\2\2\u0501\u0502\t\5\2\2\u0502") + buf.write("\u0503\t\6\2\2\u0503\5\3\2\2\2\u0504\u0505\t\2\2\2\u0505") + buf.write("\u0506\t\3\2\2\u0506\u0507\t\7\2\2\u0507\u0508\t\4\2\2") + buf.write("\u0508\u0509\t\b\2\2\u0509\u050a\t\t\2\2\u050a\u050b\t") + buf.write("\6\2\2\u050b\u050c\t\n\2\2\u050c\7\3\2\2\2\u050d\u050e") + buf.write("\t\2\2\2\u050e\u050f\t\13\2\2\u050f\u0510\t\13\2\2\u0510") + buf.write("\u0511\t\n\2\2\u0511\u0512\t\7\2\2\u0512\u0513\t\7\2\2") + buf.write("\u0513\t\3\2\2\2\u0514\u0515\t\2\2\2\u0515\u0516\t\13") + buf.write("\2\2\u0516\u0517\t\6\2\2\u0517\u0518\t\f\2\2\u0518\u0519") + buf.write("\t\4\2\2\u0519\u051a\t\r\2\2\u051a\13\3\2\2\2\u051b\u051c") + buf.write("\t\2\2\2\u051c\u051d\t\16\2\2\u051d\u051e\t\16\2\2\u051e") + buf.write("\r\3\2\2\2\u051f\u0520\t\2\2\2\u0520\u0521\t\16\2\2\u0521") + buf.write("\u0522\t\17\2\2\u0522\u0523\t\f\2\2\u0523\u0524\t\r\2") + buf.write("\2\u0524\17\3\2\2\2\u0525\u0526\t\2\2\2\u0526\u0527\t") + buf.write("\20\2\2\u0527\u0528\t\6\2\2\u0528\u0529\t\n\2\2\u0529") + buf.write("\u052a\t\5\2\2\u052a\21\3\2\2\2\u052b\u052c\t\2\2\2\u052c") + buf.write("\u052d\t\21\2\2\u052d\u052e\t\21\2\2\u052e\u052f\t\5\2") + buf.write("\2\u052f\u0530\t\n\2\2\u0530\u0531\t\21\2\2\u0531\u0532") + buf.write("\t\2\2\2\u0532\u0533\t\6\2\2\u0533\u0534\t\n\2\2\u0534") + buf.write("\23\3\2\2\2\u0535\u0536\t\2\2\2\u0536\u0537\t\b\2\2\u0537") + buf.write("\u0538\t\7\2\2\u0538\u0539\t\4\2\2\u0539\25\3\2\2\2\u053a") + buf.write("\u053b\t\2\2\2\u053b\u053c\t\b\2\2\u053c\u053d\t\6\2\2") + buf.write("\u053d\u053e\t\n\2\2\u053e\u053f\t\5\2\2\u053f\27\3\2") + buf.write("\2\2\u0540\u0541\t\2\2\2\u0541\u0542\t\b\2\2\u0542\u0543") + buf.write("\t\22\2\2\u0543\u0544\t\2\2\2\u0544\u0545\t\23\2\2\u0545") + buf.write("\u0546\t\7\2\2\u0546\31\3\2\2\2\u0547\u0548\t\2\2\2\u0548") + buf.write("\u0549\t\7\2\2\u0549\u054a\t\7\2\2\u054a\u054b\t\n\2\2") + buf.write("\u054b\u054c\t\5\2\2\u054c\u054d\t\6\2\2\u054d\u054e\t") + buf.write("\f\2\2\u054e\u054f\t\4\2\2\u054f\u0550\t\r\2\2\u0550\33") + buf.write("\3\2\2\2\u0551\u0552\t\2\2\2\u0552\u0553\t\7\2\2\u0553") + buf.write("\u0554\t\7\2\2\u0554\u0555\t\f\2\2\u0555\u0556\t\21\2") + buf.write("\2\u0556\u0557\t\r\2\2\u0557\u0558\t\17\2\2\u0558\u0559") + buf.write("\t\n\2\2\u0559\u055a\t\r\2\2\u055a\u055b\t\6\2\2\u055b") + buf.write("\35\3\2\2\2\u055c\u055d\t\2\2\2\u055d\u055e\t\6\2\2\u055e") + buf.write("\37\3\2\2\2\u055f\u0560\t\2\2\2\u0560\u0561\t\6\2\2\u0561") + buf.write("\u0562\t\6\2\2\u0562\u0563\t\2\2\2\u0563\u0564\t\13\2") + buf.write("\2\u0564\u0565\t\24\2\2\u0565!\3\2\2\2\u0566\u0567\t\2") + buf.write("\2\2\u0567\u0568\t\6\2\2\u0568\u0569\t\6\2\2\u0569\u056a") + buf.write("\t\5\2\2\u056a\u056b\t\f\2\2\u056b\u056c\t\3\2\2\u056c") + buf.write("\u056d\t\t\2\2\u056d\u056e\t\6\2\2\u056e\u056f\t\n\2\2") + buf.write("\u056f#\3\2\2\2\u0570\u0571\t\3\2\2\u0571\u0572\t\2\2") + buf.write("\2\u0572\u0573\t\13\2\2\u0573\u0574\t\25\2\2\u0574\u0575") + buf.write("\t\22\2\2\u0575\u0576\t\2\2\2\u0576\u0577\t\5\2\2\u0577") + buf.write("\u0578\t\16\2\2\u0578%\3\2\2\2\u0579\u057a\t\3\2\2\u057a") + buf.write("\u057b\t\n\2\2\u057b\u057c\t\20\2\2\u057c\u057d\t\4\2") + buf.write("\2\u057d\u057e\t\5\2\2\u057e\u057f\t\n\2\2\u057f\'\3\2") + buf.write("\2\2\u0580\u0581\t\3\2\2\u0581\u0582\t\n\2\2\u0582\u0583") + buf.write("\t\21\2\2\u0583\u0584\t\f\2\2\u0584\u0585\t\r\2\2\u0585") + buf.write(")\3\2\2\2\u0586\u0587\t\3\2\2\u0587\u0588\t\23\2\2\u0588") + buf.write("+\3\2\2\2\u0589\u058a\t\13\2\2\u058a\u058b\t\2\2\2\u058b") + buf.write("\u058c\t\13\2\2\u058c\u058d\t\24\2\2\u058d\u058e\t\n\2") + buf.write("\2\u058e-\3\2\2\2\u058f\u0590\t\13\2\2\u0590\u0591\t\2") + buf.write("\2\2\u0591\u0592\t\b\2\2\u0592\u0593\t\b\2\2\u0593/\3") + buf.write("\2\2\2\u0594\u0595\t\13\2\2\u0595\u0596\t\2\2\2\u0596") + buf.write("\u0597\t\b\2\2\u0597\u0598\t\b\2\2\u0598\u0599\t\n\2\2") + buf.write("\u0599\u059a\t\16\2\2\u059a\61\3\2\2\2\u059b\u059c\t\13") + buf.write("\2\2\u059c\u059d\t\2\2\2\u059d\u059e\t\7\2\2\u059e\u059f") + buf.write("\t\13\2\2\u059f\u05a0\t\2\2\2\u05a0\u05a1\t\16\2\2\u05a1") + buf.write("\u05a2\t\n\2\2\u05a2\63\3\2\2\2\u05a3\u05a4\t\13\2\2\u05a4") + buf.write("\u05a5\t\2\2\2\u05a5\u05a6\t\7\2\2\u05a6\u05a7\t\13\2") + buf.write("\2\u05a7\u05a8\t\2\2\2\u05a8\u05a9\t\16\2\2\u05a9\u05aa") + buf.write("\t\n\2\2\u05aa\u05ab\t\16\2\2\u05ab\65\3\2\2\2\u05ac\u05ad") + buf.write("\t\13\2\2\u05ad\u05ae\t\2\2\2\u05ae\u05af\t\6\2\2\u05af") + buf.write("\u05b0\t\2\2\2\u05b0\u05b1\t\b\2\2\u05b1\u05b2\t\4\2\2") + buf.write("\u05b2\u05b3\t\21\2\2\u05b3\67\3\2\2\2\u05b4\u05b5\t\13") + buf.write("\2\2\u05b5\u05b6\t\24\2\2\u05b6\u05b7\t\2\2\2\u05b7\u05b8") + buf.write("\t\f\2\2\u05b8\u05b9\t\r\2\2\u05b99\3\2\2\2\u05ba\u05bb") + buf.write("\t\13\2\2\u05bb\u05bc\t\24\2\2\u05bc\u05bd\t\2\2\2\u05bd") + buf.write("\u05be\t\5\2\2\u05be\u05bf\t\2\2\2\u05bf\u05c0\t\13\2") + buf.write("\2\u05c0\u05c1\t\6\2\2\u05c1\u05c2\t\n\2\2\u05c2\u05c3") + buf.write("\t\5\2\2\u05c3\u05c4\t\f\2\2\u05c4\u05c5\t\7\2\2\u05c5") + buf.write("\u05c6\t\6\2\2\u05c6\u05c7\t\f\2\2\u05c7\u05c8\t\13\2") + buf.write("\2\u05c8\u05c9\t\7\2\2\u05c9;\3\2\2\2\u05ca\u05cb\t\13") + buf.write("\2\2\u05cb\u05cc\t\24\2\2\u05cc\u05cd\t\n\2\2\u05cd\u05ce") + buf.write("\t\13\2\2\u05ce\u05cf\t\25\2\2\u05cf\u05d0\t\26\2\2\u05d0") + buf.write("\u05d1\t\4\2\2\u05d1\u05d2\t\f\2\2\u05d2\u05d3\t\r\2\2") + buf.write("\u05d3\u05d4\t\6\2\2\u05d4=\3\2\2\2\u05d5\u05d6\t\13\2") + buf.write("\2\u05d6\u05d7\t\b\2\2\u05d7\u05d8\t\2\2\2\u05d8\u05d9") + buf.write("\t\7\2\2\u05d9\u05da\t\7\2\2\u05da?\3\2\2\2\u05db\u05dc") + buf.write("\t\13\2\2\u05dc\u05dd\t\b\2\2\u05dd\u05de\t\4\2\2\u05de") + buf.write("\u05df\t\7\2\2\u05df\u05e0\t\n\2\2\u05e0A\3\2\2\2\u05e1") + buf.write("\u05e2\t\13\2\2\u05e2\u05e3\t\b\2\2\u05e3\u05e4\t\t\2") + buf.write("\2\u05e4\u05e5\t\7\2\2\u05e5\u05e6\t\6\2\2\u05e6\u05e7") + buf.write("\t\n\2\2\u05e7\u05e8\t\5\2\2\u05e8C\3\2\2\2\u05e9\u05ea") + buf.write("\t\13\2\2\u05ea\u05eb\t\4\2\2\u05eb\u05ec\t\b\2\2\u05ec") + buf.write("\u05ed\t\t\2\2\u05ed\u05ee\t\17\2\2\u05ee\u05ef\t\r\2") + buf.write("\2\u05ef\u05f0\t\7\2\2\u05f0E\3\2\2\2\u05f1\u05f2\t\13") + buf.write("\2\2\u05f2\u05f3\t\4\2\2\u05f3\u05f4\t\17\2\2\u05f4\u05f5") + buf.write("\t\17\2\2\u05f5\u05f6\t\n\2\2\u05f6\u05f7\t\r\2\2\u05f7") + buf.write("\u05f8\t\6\2\2\u05f8G\3\2\2\2\u05f9\u05fa\t\13\2\2\u05fa") + buf.write("\u05fb\t\4\2\2\u05fb\u05fc\t\17\2\2\u05fc\u05fd\t\17\2") + buf.write("\2\u05fd\u05fe\t\n\2\2\u05fe\u05ff\t\r\2\2\u05ff\u0600") + buf.write("\t\6\2\2\u0600\u0601\t\7\2\2\u0601I\3\2\2\2\u0602\u0603") + buf.write("\t\13\2\2\u0603\u0604\t\4\2\2\u0604\u0605\t\17\2\2\u0605") + buf.write("\u0606\t\17\2\2\u0606\u0607\t\f\2\2\u0607\u0608\t\6\2") + buf.write("\2\u0608K\3\2\2\2\u0609\u060a\t\13\2\2\u060a\u060b\t\4") + buf.write("\2\2\u060b\u060c\t\17\2\2\u060c\u060d\t\17\2\2\u060d\u060e") + buf.write("\t\f\2\2\u060e\u060f\t\6\2\2\u060f\u0610\t\6\2\2\u0610") + buf.write("\u0611\t\n\2\2\u0611\u0612\t\16\2\2\u0612M\3\2\2\2\u0613") + buf.write("\u0614\t\13\2\2\u0614\u0615\t\4\2\2\u0615\u0616\t\r\2") + buf.write("\2\u0616\u0617\t\20\2\2\u0617\u0618\t\f\2\2\u0618\u0619") + buf.write("\t\21\2\2\u0619\u061a\t\t\2\2\u061a\u061b\t\5\2\2\u061b") + buf.write("\u061c\t\2\2\2\u061c\u061d\t\6\2\2\u061d\u061e\t\f\2\2") + buf.write("\u061e\u061f\t\4\2\2\u061f\u0620\t\r\2\2\u0620O\3\2\2") + buf.write("\2\u0621\u0622\t\13\2\2\u0622\u0623\t\4\2\2\u0623\u0624") + buf.write("\t\r\2\2\u0624\u0625\t\20\2\2\u0625\u0626\t\b\2\2\u0626") + buf.write("\u0627\t\f\2\2\u0627\u0628\t\13\2\2\u0628\u0629\t\6\2") + buf.write("\2\u0629Q\3\2\2\2\u062a\u062b\t\13\2\2\u062b\u062c\t\4") + buf.write("\2\2\u062c\u062d\t\r\2\2\u062d\u062e\t\r\2\2\u062e\u062f") + buf.write("\t\n\2\2\u062f\u0630\t\13\2\2\u0630\u0631\t\6\2\2\u0631") + buf.write("\u0632\t\f\2\2\u0632\u0633\t\4\2\2\u0633\u0634\t\r\2\2") + buf.write("\u0634S\3\2\2\2\u0635\u0636\t\13\2\2\u0636\u0637\t\4\2") + buf.write("\2\u0637\u0638\t\r\2\2\u0638\u0639\t\7\2\2\u0639\u063a") + buf.write("\t\6\2\2\u063a\u063b\t\5\2\2\u063b\u063c\t\2\2\2\u063c") + buf.write("\u063d\t\f\2\2\u063d\u063e\t\r\2\2\u063e\u063f\t\6\2\2") + buf.write("\u063f\u0640\t\7\2\2\u0640U\3\2\2\2\u0641\u0642\t\13\2") + buf.write("\2\u0642\u0643\t\4\2\2\u0643\u0644\t\r\2\2\u0644\u0645") + buf.write("\t\6\2\2\u0645\u0646\t\n\2\2\u0646\u0647\t\r\2\2\u0647") + buf.write("\u0648\t\6\2\2\u0648W\3\2\2\2\u0649\u064a\t\13\2\2\u064a") + buf.write("\u064b\t\4\2\2\u064b\u064c\t\r\2\2\u064c\u064d\t\6\2\2") + buf.write("\u064d\u064e\t\f\2\2\u064e\u064f\t\r\2\2\u064f\u0650\t") + buf.write("\t\2\2\u0650\u0651\t\n\2\2\u0651Y\3\2\2\2\u0652\u0653") + buf.write("\t\13\2\2\u0653\u0654\t\4\2\2\u0654\u0655\t\r\2\2\u0655") + buf.write("\u0656\t\27\2\2\u0656\u0657\t\n\2\2\u0657\u0658\t\5\2") + buf.write("\2\u0658\u0659\t\7\2\2\u0659\u065a\t\f\2\2\u065a\u065b") + buf.write("\t\4\2\2\u065b\u065c\t\r\2\2\u065c[\3\2\2\2\u065d\u065e") + buf.write("\t\13\2\2\u065e\u065f\t\4\2\2\u065f\u0660\t\26\2\2\u0660") + buf.write("\u0661\t\23\2\2\u0661]\3\2\2\2\u0662\u0663\t\13\2\2\u0663") + buf.write("\u0664\t\4\2\2\u0664\u0665\t\7\2\2\u0665\u0666\t\6\2\2") + buf.write("\u0666_\3\2\2\2\u0667\u0668\t\13\2\2\u0668\u0669\t\7\2") + buf.write("\2\u0669\u066a\t\27\2\2\u066aa\3\2\2\2\u066b\u066c\t\13") + buf.write("\2\2\u066c\u066d\t\t\2\2\u066d\u066e\t\3\2\2\u066e\u066f") + buf.write("\t\n\2\2\u066fc\3\2\2\2\u0670\u0671\t\13\2\2\u0671\u0672") + buf.write("\t\t\2\2\u0672\u0673\t\5\2\2\u0673\u0674\t\5\2\2\u0674") + buf.write("\u0675\t\n\2\2\u0675\u0676\t\r\2\2\u0676\u0677\t\6\2\2") + buf.write("\u0677e\3\2\2\2\u0678\u0679\t\13\2\2\u0679\u067a\t\t\2") + buf.write("\2\u067a\u067b\t\5\2\2\u067b\u067c\t\7\2\2\u067c\u067d") + buf.write("\t\4\2\2\u067d\u067e\t\5\2\2\u067eg\3\2\2\2\u067f\u0680") + buf.write("\t\13\2\2\u0680\u0681\t\23\2\2\u0681\u0682\t\13\2\2\u0682") + buf.write("\u0683\t\b\2\2\u0683\u0684\t\n\2\2\u0684i\3\2\2\2\u0685") + buf.write("\u0686\t\16\2\2\u0686\u0687\t\2\2\2\u0687\u0688\t\6\2") + buf.write("\2\u0688\u0689\t\2\2\2\u0689k\3\2\2\2\u068a\u068b\t\16") + buf.write("\2\2\u068b\u068c\t\2\2\2\u068c\u068d\t\6\2\2\u068d\u068e") + buf.write("\t\2\2\2\u068e\u068f\t\3\2\2\u068f\u0690\t\2\2\2\u0690") + buf.write("\u0691\t\7\2\2\u0691\u0692\t\n\2\2\u0692m\3\2\2\2\u0693") + buf.write("\u0694\t\16\2\2\u0694\u0695\t\2\2\2\u0695\u0696\t\23\2") + buf.write("\2\u0696o\3\2\2\2\u0697\u0698\t\16\2\2\u0698\u0699\t\n") + buf.write("\2\2\u0699\u069a\t\2\2\2\u069a\u069b\t\b\2\2\u069b\u069c") + buf.write("\t\b\2\2\u069c\u069d\t\4\2\2\u069d\u069e\t\13\2\2\u069e") + buf.write("\u069f\t\2\2\2\u069f\u06a0\t\6\2\2\u06a0\u06a1\t\n\2\2") + buf.write("\u06a1q\3\2\2\2\u06a2\u06a3\t\16\2\2\u06a3\u06a4\t\n\2") + buf.write("\2\u06a4\u06a5\t\13\2\2\u06a5\u06a6\t\b\2\2\u06a6\u06a7") + buf.write("\t\2\2\2\u06a7\u06a8\t\5\2\2\u06a8\u06a9\t\n\2\2\u06a9") + buf.write("s\3\2\2\2\u06aa\u06ab\t\16\2\2\u06ab\u06ac\t\n\2\2\u06ac") + buf.write("\u06ad\t\20\2\2\u06ad\u06ae\t\2\2\2\u06ae\u06af\t\t\2") + buf.write("\2\u06af\u06b0\t\b\2\2\u06b0\u06b1\t\6\2\2\u06b1\u06b2") + buf.write("\t\7\2\2\u06b2u\3\2\2\2\u06b3\u06b4\t\16\2\2\u06b4\u06b5") + buf.write("\t\n\2\2\u06b5\u06b6\t\20\2\2\u06b6\u06b7\t\n\2\2\u06b7") + buf.write("\u06b8\t\5\2\2\u06b8\u06b9\t\5\2\2\u06b9\u06ba\t\n\2\2") + buf.write("\u06ba\u06bb\t\16\2\2\u06bbw\3\2\2\2\u06bc\u06bd\t\16") + buf.write("\2\2\u06bd\u06be\t\n\2\2\u06be\u06bf\t\20\2\2\u06bf\u06c0") + buf.write("\t\f\2\2\u06c0\u06c1\t\r\2\2\u06c1\u06c2\t\n\2\2\u06c2") + buf.write("\u06c3\t\5\2\2\u06c3y\3\2\2\2\u06c4\u06c5\t\16\2\2\u06c5") + buf.write("\u06c6\t\n\2\2\u06c6\u06c7\t\b\2\2\u06c7\u06c8\t\n\2\2") + buf.write("\u06c8\u06c9\t\6\2\2\u06c9\u06ca\t\n\2\2\u06ca{\3\2\2") + buf.write("\2\u06cb\u06cc\t\16\2\2\u06cc\u06cd\t\n\2\2\u06cd\u06ce") + buf.write("\t\b\2\2\u06ce\u06cf\t\f\2\2\u06cf\u06d0\t\17\2\2\u06d0") + buf.write("\u06d1\t\f\2\2\u06d1\u06d2\t\6\2\2\u06d2\u06d3\t\n\2\2") + buf.write("\u06d3\u06d4\t\5\2\2\u06d4}\3\2\2\2\u06d5\u06d6\t\16\2") + buf.write("\2\u06d6\u06d7\t\n\2\2\u06d7\u06d8\t\b\2\2\u06d8\u06d9") + buf.write("\t\f\2\2\u06d9\u06da\t\17\2\2\u06da\u06db\t\f\2\2\u06db") + buf.write("\u06dc\t\6\2\2\u06dc\u06dd\t\n\2\2\u06dd\u06de\t\5\2\2") + buf.write("\u06de\u06df\t\7\2\2\u06df\177\3\2\2\2\u06e0\u06e1\t\16") + buf.write("\2\2\u06e1\u06e2\t\n\2\2\u06e2\u06e3\t\26\2\2\u06e3\u06e4") + buf.write("\t\n\2\2\u06e4\u06e5\t\r\2\2\u06e5\u06e6\t\16\2\2\u06e6") + buf.write("\u06e7\t\7\2\2\u06e7\u0081\3\2\2\2\u06e8\u06e9\t\16\2") + buf.write("\2\u06e9\u06ea\t\n\2\2\u06ea\u06eb\t\6\2\2\u06eb\u06ec") + buf.write("\t\2\2\2\u06ec\u06ed\t\13\2\2\u06ed\u06ee\t\24\2\2\u06ee") + buf.write("\u0083\3\2\2\2\u06ef\u06f0\t\16\2\2\u06f0\u06f1\t\f\2") + buf.write("\2\u06f1\u06f2\t\13\2\2\u06f2\u06f3\t\6\2\2\u06f3\u06f4") + buf.write("\t\f\2\2\u06f4\u06f5\t\4\2\2\u06f5\u06f6\t\r\2\2\u06f6") + buf.write("\u06f7\t\2\2\2\u06f7\u06f8\t\5\2\2\u06f8\u06f9\t\23\2") + buf.write("\2\u06f9\u0085\3\2\2\2\u06fa\u06fb\t\16\2\2\u06fb\u06fc") + buf.write("\t\f\2\2\u06fc\u06fd\t\7\2\2\u06fd\u06fe\t\2\2\2\u06fe") + buf.write("\u06ff\t\3\2\2\u06ff\u0700\t\b\2\2\u0700\u0701\t\n\2\2") + buf.write("\u0701\u0087\3\2\2\2\u0702\u0703\t\16\2\2\u0703\u0704") + buf.write("\t\f\2\2\u0704\u0705\t\7\2\2\u0705\u0706\t\13\2\2\u0706") + buf.write("\u0707\t\2\2\2\u0707\u0708\t\5\2\2\u0708\u0709\t\16\2") + buf.write("\2\u0709\u0089\3\2\2\2\u070a\u070b\t\16\2\2\u070b\u070c") + buf.write("\t\4\2\2\u070c\u070d\t\13\2\2\u070d\u070e\t\t\2\2\u070e") + buf.write("\u070f\t\17\2\2\u070f\u0710\t\n\2\2\u0710\u0711\t\r\2") + buf.write("\2\u0711\u0712\t\6\2\2\u0712\u008b\3\2\2\2\u0713\u0714") + buf.write("\t\16\2\2\u0714\u0715\t\4\2\2\u0715\u0716\t\17\2\2\u0716") + buf.write("\u0717\t\2\2\2\u0717\u0718\t\f\2\2\u0718\u0719\t\r\2\2") + buf.write("\u0719\u008d\3\2\2\2\u071a\u071b\t\16\2\2\u071b\u071c") + buf.write("\t\4\2\2\u071c\u071d\t\t\2\2\u071d\u071e\t\3\2\2\u071e") + buf.write("\u071f\t\b\2\2\u071f\u0720\t\n\2\2\u0720\u008f\3\2\2\2") + buf.write("\u0721\u0722\t\16\2\2\u0722\u0723\t\5\2\2\u0723\u0724") + buf.write("\t\4\2\2\u0724\u0725\t\26\2\2\u0725\u0091\3\2\2\2\u0726") + buf.write("\u0727\t\n\2\2\u0727\u0728\t\2\2\2\u0728\u0729\t\13\2") + buf.write("\2\u0729\u072a\t\24\2\2\u072a\u0093\3\2\2\2\u072b\u072c") + buf.write("\t\n\2\2\u072c\u072d\t\r\2\2\u072d\u072e\t\2\2\2\u072e") + buf.write("\u072f\t\3\2\2\u072f\u0730\t\b\2\2\u0730\u0731\t\n\2\2") + buf.write("\u0731\u0095\3\2\2\2\u0732\u0733\t\n\2\2\u0733\u0734\t") + buf.write("\r\2\2\u0734\u0735\t\13\2\2\u0735\u0736\t\4\2\2\u0736") + buf.write("\u0737\t\16\2\2\u0737\u0738\t\f\2\2\u0738\u0739\t\r\2") + buf.write("\2\u0739\u073a\t\21\2\2\u073a\u0097\3\2\2\2\u073b\u073c") + buf.write("\t\n\2\2\u073c\u073d\t\r\2\2\u073d\u073e\t\13\2\2\u073e") + buf.write("\u073f\t\5\2\2\u073f\u0740\t\23\2\2\u0740\u0741\t\26\2") + buf.write("\2\u0741\u0742\t\6\2\2\u0742\u0743\t\n\2\2\u0743\u0744") + buf.write("\t\16\2\2\u0744\u0099\3\2\2\2\u0745\u0746\t\n\2\2\u0746") + buf.write("\u0747\t\r\2\2\u0747\u0748\t\t\2\2\u0748\u0749\t\17\2") + buf.write("\2\u0749\u009b\3\2\2\2\u074a\u074b\t\n\2\2\u074b\u074c") + buf.write("\t\7\2\2\u074c\u074d\t\13\2\2\u074d\u074e\t\2\2\2\u074e") + buf.write("\u074f\t\26\2\2\u074f\u0750\t\n\2\2\u0750\u009d\3\2\2") + buf.write("\2\u0751\u0752\t\n\2\2\u0752\u0753\t\27\2\2\u0753\u0754") + buf.write("\t\n\2\2\u0754\u0755\t\r\2\2\u0755\u0756\t\6\2\2\u0756") + buf.write("\u009f\3\2\2\2\u0757\u0758\t\n\2\2\u0758\u0759\t\30\2") + buf.write("\2\u0759\u075a\t\13\2\2\u075a\u075b\t\b\2\2\u075b\u075c") + buf.write("\t\t\2\2\u075c\u075d\t\16\2\2\u075d\u075e\t\n\2\2\u075e") + buf.write("\u00a1\3\2\2\2\u075f\u0760\t\n\2\2\u0760\u0761\t\30\2") + buf.write("\2\u0761\u0762\t\13\2\2\u0762\u0763\t\b\2\2\u0763\u0764") + buf.write("\t\t\2\2\u0764\u0765\t\16\2\2\u0765\u0766\t\f\2\2\u0766") + buf.write("\u0767\t\r\2\2\u0767\u0768\t\21\2\2\u0768\u00a3\3\2\2") + buf.write("\2\u0769\u076a\t\n\2\2\u076a\u076b\t\30\2\2\u076b\u076c") + buf.write("\t\13\2\2\u076c\u076d\t\b\2\2\u076d\u076e\t\t\2\2\u076e") + buf.write("\u076f\t\7\2\2\u076f\u0770\t\f\2\2\u0770\u0771\t\27\2") + buf.write("\2\u0771\u0772\t\n\2\2\u0772\u00a5\3\2\2\2\u0773\u0774") + buf.write("\t\n\2\2\u0774\u0775\t\30\2\2\u0775\u0776\t\n\2\2\u0776") + buf.write("\u0777\t\13\2\2\u0777\u0778\t\t\2\2\u0778\u0779\t\6\2") + buf.write("\2\u0779\u077a\t\n\2\2\u077a\u00a7\3\2\2\2\u077b\u077c") + buf.write("\t\n\2\2\u077c\u077d\t\30\2\2\u077d\u077e\t\26\2\2\u077e") + buf.write("\u077f\t\b\2\2\u077f\u0780\t\2\2\2\u0780\u0781\t\f\2\2") + buf.write("\u0781\u0782\t\r\2\2\u0782\u00a9\3\2\2\2\u0783\u0784\t") + buf.write("\n\2\2\u0784\u0785\t\30\2\2\u0785\u0786\t\6\2\2\u0786") + buf.write("\u0787\t\n\2\2\u0787\u0788\t\r\2\2\u0788\u0789\t\7\2\2") + buf.write("\u0789\u078a\t\f\2\2\u078a\u078b\t\4\2\2\u078b\u078c\t") + buf.write("\r\2\2\u078c\u00ab\3\2\2\2\u078d\u078e\t\n\2\2\u078e\u078f") + buf.write("\t\30\2\2\u078f\u0790\t\6\2\2\u0790\u0791\t\n\2\2\u0791") + buf.write("\u0792\t\5\2\2\u0792\u0793\t\r\2\2\u0793\u0794\t\2\2\2") + buf.write("\u0794\u0795\t\b\2\2\u0795\u00ad\3\2\2\2\u0796\u0797\t") + buf.write("\20\2\2\u0797\u0798\t\2\2\2\u0798\u0799\t\17\2\2\u0799") + buf.write("\u079a\t\f\2\2\u079a\u079b\t\b\2\2\u079b\u079c\t\23\2") + buf.write("\2\u079c\u00af\3\2\2\2\u079d\u079e\t\20\2\2\u079e\u079f") + buf.write("\t\f\2\2\u079f\u07a0\t\b\2\2\u07a0\u07a1\t\6\2\2\u07a1") + buf.write("\u07a2\t\n\2\2\u07a2\u07a3\t\5\2\2\u07a3\u00b1\3\2\2\2") + buf.write("\u07a4\u07a5\t\20\2\2\u07a5\u07a6\t\f\2\2\u07a6\u07a7") + buf.write("\t\5\2\2\u07a7\u07a8\t\7\2\2\u07a8\u07a9\t\6\2\2\u07a9") + buf.write("\u00b3\3\2\2\2\u07aa\u07ab\t\20\2\2\u07ab\u07ac\t\4\2") + buf.write("\2\u07ac\u07ad\t\b\2\2\u07ad\u07ae\t\b\2\2\u07ae\u07af") + buf.write("\t\4\2\2\u07af\u07b0\t\22\2\2\u07b0\u07b1\t\f\2\2\u07b1") + buf.write("\u07b2\t\r\2\2\u07b2\u07b3\t\21\2\2\u07b3\u00b5\3\2\2") + buf.write("\2\u07b4\u07b5\t\20\2\2\u07b5\u07b6\t\4\2\2\u07b6\u07b7") + buf.write("\t\5\2\2\u07b7\u07b8\t\13\2\2\u07b8\u07b9\t\n\2\2\u07b9") + buf.write("\u00b7\3\2\2\2\u07ba\u07bb\t\20\2\2\u07bb\u07bc\t\4\2") + buf.write("\2\u07bc\u07bd\t\5\2\2\u07bd\u07be\t\22\2\2\u07be\u07bf") + buf.write("\t\2\2\2\u07bf\u07c0\t\5\2\2\u07c0\u07c1\t\16\2\2\u07c1") + buf.write("\u00b9\3\2\2\2\u07c2\u07c3\t\20\2\2\u07c3\u07c4\t\t\2") + buf.write("\2\u07c4\u07c5\t\r\2\2\u07c5\u07c6\t\13\2\2\u07c6\u07c7") + buf.write("\t\6\2\2\u07c7\u07c8\t\f\2\2\u07c8\u07c9\t\4\2\2\u07c9") + buf.write("\u07ca\t\r\2\2\u07ca\u00bb\3\2\2\2\u07cb\u07cc\t\20\2") + buf.write("\2\u07cc\u07cd\t\t\2\2\u07cd\u07ce\t\r\2\2\u07ce\u07cf") + buf.write("\t\13\2\2\u07cf\u07d0\t\6\2\2\u07d0\u07d1\t\f\2\2\u07d1") + buf.write("\u07d2\t\4\2\2\u07d2\u07d3\t\r\2\2\u07d3\u07d4\t\7\2\2") + buf.write("\u07d4\u00bd\3\2\2\2\u07d5\u07d6\t\21\2\2\u07d6\u07d7") + buf.write("\t\n\2\2\u07d7\u07d8\t\r\2\2\u07d8\u07d9\t\n\2\2\u07d9") + buf.write("\u07da\t\5\2\2\u07da\u07db\t\2\2\2\u07db\u07dc\t\6\2\2") + buf.write("\u07dc\u07dd\t\n\2\2\u07dd\u07de\t\16\2\2\u07de\u00bf") + buf.write("\3\2\2\2\u07df\u07e0\t\21\2\2\u07e0\u07e1\t\b\2\2\u07e1") + buf.write("\u07e2\t\4\2\2\u07e2\u07e3\t\3\2\2\u07e3\u07e4\t\2\2\2") + buf.write("\u07e4\u07e5\t\b\2\2\u07e5\u00c1\3\2\2\2\u07e6\u07e7\t") + buf.write("\21\2\2\u07e7\u07e8\t\5\2\2\u07e8\u07e9\t\2\2\2\u07e9") + buf.write("\u07ea\t\r\2\2\u07ea\u07eb\t\6\2\2\u07eb\u07ec\t\n\2\2") + buf.write("\u07ec\u07ed\t\16\2\2\u07ed\u00c3\3\2\2\2\u07ee\u07ef") + buf.write("\t\21\2\2\u07ef\u07f0\t\5\2\2\u07f0\u07f1\t\4\2\2\u07f1") + buf.write("\u07f2\t\t\2\2\u07f2\u07f3\t\26\2\2\u07f3\u07f4\t\7\2") + buf.write("\2\u07f4\u00c5\3\2\2\2\u07f5\u07f6\t\24\2\2\u07f6\u07f7") + buf.write("\t\2\2\2\u07f7\u07f8\t\r\2\2\u07f8\u07f9\t\16\2\2\u07f9") + buf.write("\u07fa\t\b\2\2\u07fa\u07fb\t\n\2\2\u07fb\u07fc\t\5\2\2") + buf.write("\u07fc\u00c7\3\2\2\2\u07fd\u07fe\t\24\2\2\u07fe\u07ff") + buf.write("\t\n\2\2\u07ff\u0800\t\2\2\2\u0800\u0801\t\16\2\2\u0801") + buf.write("\u0802\t\n\2\2\u0802\u0803\t\5\2\2\u0803\u00c9\3\2\2\2") + buf.write("\u0804\u0805\t\24\2\2\u0805\u0806\t\4\2\2\u0806\u0807") + buf.write("\t\b\2\2\u0807\u0808\t\16\2\2\u0808\u00cb\3\2\2\2\u0809") + buf.write("\u080a\t\24\2\2\u080a\u080b\t\4\2\2\u080b\u080c\t\t\2") + buf.write("\2\u080c\u080d\t\5\2\2\u080d\u00cd\3\2\2\2\u080e\u080f") + buf.write("\t\f\2\2\u080f\u0810\t\16\2\2\u0810\u0811\t\n\2\2\u0811") + buf.write("\u0812\t\r\2\2\u0812\u0813\t\6\2\2\u0813\u0814\t\f\2\2") + buf.write("\u0814\u0815\t\6\2\2\u0815\u0816\t\23\2\2\u0816\u00cf") + buf.write("\3\2\2\2\u0817\u0818\t\f\2\2\u0818\u0819\t\20\2\2\u0819") + buf.write("\u00d1\3\2\2\2\u081a\u081b\t\f\2\2\u081b\u081c\t\17\2") + buf.write("\2\u081c\u081d\t\17\2\2\u081d\u081e\t\n\2\2\u081e\u081f") + buf.write("\t\16\2\2\u081f\u0820\t\f\2\2\u0820\u0821\t\2\2\2\u0821") + buf.write("\u0822\t\6\2\2\u0822\u0823\t\n\2\2\u0823\u00d3\3\2\2\2") + buf.write("\u0824\u0825\t\f\2\2\u0825\u0826\t\17\2\2\u0826\u0827") + buf.write("\t\17\2\2\u0827\u0828\t\t\2\2\u0828\u0829\t\6\2\2\u0829") + buf.write("\u082a\t\2\2\2\u082a\u082b\t\3\2\2\u082b\u082c\t\b\2\2") + buf.write("\u082c\u082d\t\n\2\2\u082d\u00d5\3\2\2\2\u082e\u082f\t") + buf.write("\f\2\2\u082f\u0830\t\17\2\2\u0830\u0831\t\26\2\2\u0831") + buf.write("\u0832\t\b\2\2\u0832\u0833\t\f\2\2\u0833\u0834\t\13\2") + buf.write("\2\u0834\u0835\t\f\2\2\u0835\u0836\t\6\2\2\u0836\u00d7") + buf.write("\3\2\2\2\u0837\u0838\t\f\2\2\u0838\u0839\t\17\2\2\u0839") + buf.write("\u083a\t\26\2\2\u083a\u083b\t\4\2\2\u083b\u083c\t\5\2") + buf.write("\2\u083c\u083d\t\6\2\2\u083d\u00d9\3\2\2\2\u083e\u083f") + buf.write("\t\f\2\2\u083f\u0840\t\r\2\2\u0840\u0841\t\13\2\2\u0841") + buf.write("\u0842\t\b\2\2\u0842\u0843\t\t\2\2\u0843\u0844\t\16\2") + buf.write("\2\u0844\u0845\t\n\2\2\u0845\u00db\3\2\2\2\u0846\u0847") + buf.write("\t\f\2\2\u0847\u0848\t\r\2\2\u0848\u0849\t\13\2\2\u0849") + buf.write("\u084a\t\b\2\2\u084a\u084b\t\t\2\2\u084b\u084c\t\16\2") + buf.write("\2\u084c\u084d\t\f\2\2\u084d\u084e\t\r\2\2\u084e\u084f") + buf.write("\t\21\2\2\u084f\u00dd\3\2\2\2\u0850\u0851\t\f\2\2\u0851") + buf.write("\u0852\t\r\2\2\u0852\u0853\t\13\2\2\u0853\u0854\t\5\2") + buf.write("\2\u0854\u0855\t\n\2\2\u0855\u0856\t\17\2\2\u0856\u0857") + buf.write("\t\n\2\2\u0857\u0858\t\r\2\2\u0858\u0859\t\6\2\2\u0859") + buf.write("\u00df\3\2\2\2\u085a\u085b\t\f\2\2\u085b\u085c\t\r\2\2") + buf.write("\u085c\u085d\t\16\2\2\u085d\u085e\t\n\2\2\u085e\u085f") + buf.write("\t\30\2\2\u085f\u00e1\3\2\2\2\u0860\u0861\t\f\2\2\u0861") + buf.write("\u0862\t\r\2\2\u0862\u0863\t\16\2\2\u0863\u0864\t\n\2") + buf.write("\2\u0864\u0865\t\30\2\2\u0865\u0866\t\n\2\2\u0866\u0867") + buf.write("\t\7\2\2\u0867\u00e3\3\2\2\2\u0868\u0869\t\f\2\2\u0869") + buf.write("\u086a\t\r\2\2\u086a\u086b\t\24\2\2\u086b\u086c\t\n\2") + buf.write("\2\u086c\u086d\t\5\2\2\u086d\u086e\t\f\2\2\u086e\u086f") + buf.write("\t\6\2\2\u086f\u00e5\3\2\2\2\u0870\u0871\t\f\2\2\u0871") + buf.write("\u0872\t\r\2\2\u0872\u0873\t\24\2\2\u0873\u0874\t\n\2") + buf.write("\2\u0874\u0875\t\5\2\2\u0875\u0876\t\f\2\2\u0876\u0877") + buf.write("\t\6\2\2\u0877\u0878\t\7\2\2\u0878\u00e7\3\2\2\2\u0879") + buf.write("\u087a\t\f\2\2\u087a\u087b\t\r\2\2\u087b\u087c\t\b\2\2") + buf.write("\u087c\u087d\t\f\2\2\u087d\u087e\t\r\2\2\u087e\u087f\t") + buf.write("\n\2\2\u087f\u00e9\3\2\2\2\u0880\u0881\t\f\2\2\u0881\u0882") + buf.write("\t\r\2\2\u0882\u0883\t\26\2\2\u0883\u0884\t\t\2\2\u0884") + buf.write("\u0885\t\6\2\2\u0885\u00eb\3\2\2\2\u0886\u0887\t\f\2\2") + buf.write("\u0887\u0888\t\r\2\2\u0888\u0889\t\7\2\2\u0889\u088a\t") + buf.write("\n\2\2\u088a\u088b\t\r\2\2\u088b\u088c\t\7\2\2\u088c\u088d") + buf.write("\t\f\2\2\u088d\u088e\t\6\2\2\u088e\u088f\t\f\2\2\u088f") + buf.write("\u0890\t\27\2\2\u0890\u0891\t\n\2\2\u0891\u00ed\3\2\2") + buf.write("\2\u0892\u0893\t\f\2\2\u0893\u0894\t\r\2\2\u0894\u0895") + buf.write("\t\7\2\2\u0895\u0896\t\n\2\2\u0896\u0897\t\5\2\2\u0897") + buf.write("\u0898\t\6\2\2\u0898\u00ef\3\2\2\2\u0899\u089a\t\f\2\2") + buf.write("\u089a\u089b\t\r\2\2\u089b\u089c\t\7\2\2\u089c\u089d\t") + buf.write("\6\2\2\u089d\u089e\t\n\2\2\u089e\u089f\t\2\2\2\u089f\u08a0") + buf.write("\t\16\2\2\u08a0\u00f1\3\2\2\2\u08a1\u08a2\t\f\2\2\u08a2") + buf.write("\u08a3\t\r\2\2\u08a3\u08a4\t\27\2\2\u08a4\u08a5\t\4\2") + buf.write("\2\u08a5\u08a6\t\25\2\2\u08a6\u08a7\t\n\2\2\u08a7\u08a8") + buf.write("\t\5\2\2\u08a8\u00f3\3\2\2\2\u08a9\u08aa\t\f\2\2\u08aa") + buf.write("\u08ab\t\7\2\2\u08ab\u08ac\t\4\2\2\u08ac\u08ad\t\b\2\2") + buf.write("\u08ad\u08ae\t\2\2\2\u08ae\u08af\t\6\2\2\u08af\u08b0\t") + buf.write("\f\2\2\u08b0\u08b1\t\4\2\2\u08b1\u08b2\t\r\2\2\u08b2\u00f5") + buf.write("\3\2\2\2\u08b3\u08b4\t\25\2\2\u08b4\u08b5\t\n\2\2\u08b5") + buf.write("\u08b6\t\23\2\2\u08b6\u00f7\3\2\2\2\u08b7\u08b8\t\b\2") + buf.write("\2\u08b8\u08b9\t\2\2\2\u08b9\u08ba\t\3\2\2\u08ba\u08bb") + buf.write("\t\n\2\2\u08bb\u08bc\t\b\2\2\u08bc\u00f9\3\2\2\2\u08bd") + buf.write("\u08be\t\b\2\2\u08be\u08bf\t\2\2\2\u08bf\u08c0\t\r\2\2") + buf.write("\u08c0\u08c1\t\21\2\2\u08c1\u08c2\t\t\2\2\u08c2\u08c3") + buf.write("\t\2\2\2\u08c3\u08c4\t\21\2\2\u08c4\u08c5\t\n\2\2\u08c5") + buf.write("\u00fb\3\2\2\2\u08c6\u08c7\t\b\2\2\u08c7\u08c8\t\2\2\2") + buf.write("\u08c8\u08c9\t\5\2\2\u08c9\u08ca\t\21\2\2\u08ca\u08cb") + buf.write("\t\n\2\2\u08cb\u00fd\3\2\2\2\u08cc\u08cd\t\b\2\2\u08cd") + buf.write("\u08ce\t\2\2\2\u08ce\u08cf\t\7\2\2\u08cf\u08d0\t\6\2\2") + buf.write("\u08d0\u00ff\3\2\2\2\u08d1\u08d2\t\b\2\2\u08d2\u08d3\t") + buf.write("\n\2\2\u08d3\u08d4\t\2\2\2\u08d4\u08d5\t\25\2\2\u08d5") + buf.write("\u08d6\t\26\2\2\u08d6\u08d7\t\5\2\2\u08d7\u08d8\t\4\2") + buf.write("\2\u08d8\u08d9\t\4\2\2\u08d9\u08da\t\20\2\2\u08da\u0101") + buf.write("\3\2\2\2\u08db\u08dc\t\b\2\2\u08dc\u08dd\t\n\2\2\u08dd") + buf.write("\u08de\t\27\2\2\u08de\u08df\t\n\2\2\u08df\u08e0\t\b\2") + buf.write("\2\u08e0\u0103\3\2\2\2\u08e1\u08e2\t\b\2\2\u08e2\u08e3") + buf.write("\t\f\2\2\u08e3\u08e4\t\7\2\2\u08e4\u08e5\t\6\2\2\u08e5") + buf.write("\u08e6\t\n\2\2\u08e6\u08e7\t\r\2\2\u08e7\u0105\3\2\2\2") + buf.write("\u08e8\u08e9\t\b\2\2\u08e9\u08ea\t\4\2\2\u08ea\u08eb\t") + buf.write("\2\2\2\u08eb\u08ec\t\16\2\2\u08ec\u0107\3\2\2\2\u08ed") + buf.write("\u08ee\t\b\2\2\u08ee\u08ef\t\4\2\2\u08ef\u08f0\t\13\2") + buf.write("\2\u08f0\u08f1\t\2\2\2\u08f1\u08f2\t\b\2\2\u08f2\u0109") + buf.write("\3\2\2\2\u08f3\u08f4\t\b\2\2\u08f4\u08f5\t\4\2\2\u08f5") + buf.write("\u08f6\t\13\2\2\u08f6\u08f7\t\2\2\2\u08f7\u08f8\t\6\2") + buf.write("\2\u08f8\u08f9\t\f\2\2\u08f9\u08fa\t\4\2\2\u08fa\u08fb") + buf.write("\t\r\2\2\u08fb\u010b\3\2\2\2\u08fc\u08fd\t\b\2\2\u08fd") + buf.write("\u08fe\t\4\2\2\u08fe\u08ff\t\13\2\2\u08ff\u0900\t\25\2") + buf.write("\2\u0900\u010d\3\2\2\2\u0901\u0902\t\b\2\2\u0902\u0903") + buf.write("\t\4\2\2\u0903\u0904\t\13\2\2\u0904\u0905\t\25\2\2\u0905") + buf.write("\u0906\t\n\2\2\u0906\u0907\t\16\2\2\u0907\u010f\3\2\2") + buf.write("\2\u0908\u0909\t\b\2\2\u0909\u090a\t\4\2\2\u090a\u090b") + buf.write("\t\21\2\2\u090b\u090c\t\21\2\2\u090c\u090d\t\n\2\2\u090d") + buf.write("\u090e\t\16\2\2\u090e\u0111\3\2\2\2\u090f\u0910\t\17\2") + buf.write("\2\u0910\u0911\t\2\2\2\u0911\u0912\t\26\2\2\u0912\u0913") + buf.write("\t\26\2\2\u0913\u0914\t\f\2\2\u0914\u0915\t\r\2\2\u0915") + buf.write("\u0916\t\21\2\2\u0916\u0113\3\2\2\2\u0917\u0918\t\17\2") + buf.write("\2\u0918\u0919\t\2\2\2\u0919\u091a\t\6\2\2\u091a\u091b") + buf.write("\t\13\2\2\u091b\u091c\t\24\2\2\u091c\u0115\3\2\2\2\u091d") + buf.write("\u091e\t\17\2\2\u091e\u091f\t\2\2\2\u091f\u0920\t\6\2") + buf.write("\2\u0920\u0921\t\n\2\2\u0921\u0922\t\5\2\2\u0922\u0923") + buf.write("\t\f\2\2\u0923\u0924\t\2\2\2\u0924\u0925\t\b\2\2\u0925") + buf.write("\u0926\t\f\2\2\u0926\u0927\t\31\2\2\u0927\u0928\t\n\2") + buf.write("\2\u0928\u0929\t\16\2\2\u0929\u0117\3\2\2\2\u092a\u092b") + buf.write("\t\17\2\2\u092b\u092c\t\2\2\2\u092c\u092d\t\30\2\2\u092d") + buf.write("\u092e\t\27\2\2\u092e\u092f\t\2\2\2\u092f\u0930\t\b\2") + buf.write("\2\u0930\u0931\t\t\2\2\u0931\u0932\t\n\2\2\u0932\u0119") + buf.write("\3\2\2\2\u0933\u0934\t\17\2\2\u0934\u0935\t\n\2\2\u0935") + buf.write("\u0936\t\6\2\2\u0936\u0937\t\24\2\2\u0937\u0938\t\4\2") + buf.write("\2\u0938\u0939\t\16\2\2\u0939\u011b\3\2\2\2\u093a\u093b") + buf.write("\t\17\2\2\u093b\u093c\t\f\2\2\u093c\u093d\t\r\2\2\u093d") + buf.write("\u093e\t\t\2\2\u093e\u093f\t\6\2\2\u093f\u0940\t\n\2\2") + buf.write("\u0940\u011d\3\2\2\2\u0941\u0942\t\17\2\2\u0942\u0943") + buf.write("\t\f\2\2\u0943\u0944\t\r\2\2\u0944\u0945\t\27\2\2\u0945") + buf.write("\u0946\t\2\2\2\u0946\u0947\t\b\2\2\u0947\u0948\t\t\2\2") + buf.write("\u0948\u0949\t\n\2\2\u0949\u011f\3\2\2\2\u094a\u094b\t") + buf.write("\17\2\2\u094b\u094c\t\4\2\2\u094c\u094d\t\16\2\2\u094d") + buf.write("\u094e\t\n\2\2\u094e\u0121\3\2\2\2\u094f\u0950\t\17\2") + buf.write("\2\u0950\u0951\t\4\2\2\u0951\u0952\t\r\2\2\u0952\u0953") + buf.write("\t\6\2\2\u0953\u0954\t\24\2\2\u0954\u0123\3\2\2\2\u0955") + buf.write("\u0956\t\17\2\2\u0956\u0957\t\4\2\2\u0957\u0958\t\27\2") + buf.write("\2\u0958\u0959\t\n\2\2\u0959\u0125\3\2\2\2\u095a\u095b") + buf.write("\t\r\2\2\u095b\u095c\t\2\2\2\u095c\u095d\t\17\2\2\u095d") + buf.write("\u095e\t\n\2\2\u095e\u0127\3\2\2\2\u095f\u0960\t\r\2\2") + buf.write("\u0960\u0961\t\2\2\2\u0961\u0962\t\17\2\2\u0962\u0963") + buf.write("\t\n\2\2\u0963\u0964\t\7\2\2\u0964\u0129\3\2\2\2\u0965") + buf.write("\u0966\t\r\2\2\u0966\u0967\t\n\2\2\u0967\u0968\t\22\2") + buf.write("\2\u0968\u012b\3\2\2\2\u0969\u096a\t\r\2\2\u096a\u096b") + buf.write("\t\n\2\2\u096b\u096c\t\30\2\2\u096c\u096d\t\6\2\2\u096d") + buf.write("\u012d\3\2\2\2\u096e\u096f\t\r\2\2\u096f\u0970\t\4\2\2") + buf.write("\u0970\u012f\3\2\2\2\u0971\u0972\t\r\2\2\u0972\u0973\t") + buf.write("\4\2\2\u0973\u0974\t\6\2\2\u0974\u0975\t\24\2\2\u0975") + buf.write("\u0976\t\f\2\2\u0976\u0977\t\r\2\2\u0977\u0978\t\21\2") + buf.write("\2\u0978\u0131\3\2\2\2\u0979\u097a\t\r\2\2\u097a\u097b") + buf.write("\t\4\2\2\u097b\u097c\t\6\2\2\u097c\u097d\t\f\2\2\u097d") + buf.write("\u097e\t\20\2\2\u097e\u097f\t\23\2\2\u097f\u0133\3\2\2") + buf.write("\2\u0980\u0981\t\r\2\2\u0981\u0982\t\4\2\2\u0982\u0983") + buf.write("\t\22\2\2\u0983\u0984\t\2\2\2\u0984\u0985\t\f\2\2\u0985") + buf.write("\u0986\t\6\2\2\u0986\u0135\3\2\2\2\u0987\u0988\t\r\2\2") + buf.write("\u0988\u0989\t\t\2\2\u0989\u098a\t\b\2\2\u098a\u098b\t") + buf.write("\b\2\2\u098b\u098c\t\7\2\2\u098c\u0137\3\2\2\2\u098d\u098e") + buf.write("\t\4\2\2\u098e\u098f\t\3\2\2\u098f\u0990\t\32\2\2\u0990") + buf.write("\u0991\t\n\2\2\u0991\u0992\t\13\2\2\u0992\u0993\t\6\2") + buf.write("\2\u0993\u0139\3\2\2\2\u0994\u0995\t\4\2\2\u0995\u0996") + buf.write("\t\20\2\2\u0996\u013b\3\2\2\2\u0997\u0998\t\4\2\2\u0998") + buf.write("\u0999\t\20\2\2\u0999\u099a\t\20\2\2\u099a\u013d\3\2\2") + buf.write("\2\u099b\u099c\t\4\2\2\u099c\u099d\t\f\2\2\u099d\u099e") + buf.write("\t\16\2\2\u099e\u099f\t\7\2\2\u099f\u013f\3\2\2\2\u09a0") + buf.write("\u09a1\t\4\2\2\u09a1\u09a2\t\b\2\2\u09a2\u09a3\t\16\2") + buf.write("\2\u09a3\u0141\3\2\2\2\u09a4\u09a5\t\4\2\2\u09a5\u09a6") + buf.write("\t\26\2\2\u09a6\u09a7\t\n\2\2\u09a7\u09a8\t\5\2\2\u09a8") + buf.write("\u09a9\t\2\2\2\u09a9\u09aa\t\6\2\2\u09aa\u09ab\t\4\2\2") + buf.write("\u09ab\u09ac\t\5\2\2\u09ac\u0143\3\2\2\2\u09ad\u09ae\t") + buf.write("\4\2\2\u09ae\u09af\t\26\2\2\u09af\u09b0\t\6\2\2\u09b0") + buf.write("\u09b1\t\f\2\2\u09b1\u09b2\t\4\2\2\u09b2\u09b3\t\r\2\2") + buf.write("\u09b3\u0145\3\2\2\2\u09b4\u09b5\t\4\2\2\u09b5\u09b6\t") + buf.write("\26\2\2\u09b6\u09b7\t\6\2\2\u09b7\u09b8\t\f\2\2\u09b8") + buf.write("\u09b9\t\4\2\2\u09b9\u09ba\t\r\2\2\u09ba\u09bb\t\7\2\2") + buf.write("\u09bb\u0147\3\2\2\2\u09bc\u09bd\t\4\2\2\u09bd\u09be\t") + buf.write("\5\2\2\u09be\u09bf\t\16\2\2\u09bf\u09c0\t\f\2\2\u09c0") + buf.write("\u09c1\t\r\2\2\u09c1\u09c2\t\2\2\2\u09c2\u09c3\t\b\2\2") + buf.write("\u09c3\u09c4\t\f\2\2\u09c4\u09c5\t\6\2\2\u09c5\u09c6\t") + buf.write("\23\2\2\u09c6\u0149\3\2\2\2\u09c7\u09c8\t\4\2\2\u09c8") + buf.write("\u09c9\t\6\2\2\u09c9\u09ca\t\24\2\2\u09ca\u09cb\t\n\2") + buf.write("\2\u09cb\u09cc\t\5\2\2\u09cc\u09cd\t\7\2\2\u09cd\u014b") + buf.write("\3\2\2\2\u09ce\u09cf\t\4\2\2\u09cf\u09d0\t\27\2\2\u09d0") + buf.write("\u09d1\t\n\2\2\u09d1\u09d2\t\5\2\2\u09d2\u014d\3\2\2\2") + buf.write("\u09d3\u09d4\t\4\2\2\u09d4\u09d5\t\27\2\2\u09d5\u09d6") + buf.write("\t\n\2\2\u09d6\u09d7\t\5\2\2\u09d7\u09d8\t\5\2\2\u09d8") + buf.write("\u09d9\t\f\2\2\u09d9\u09da\t\16\2\2\u09da\u09db\t\f\2") + buf.write("\2\u09db\u09dc\t\r\2\2\u09dc\u09dd\t\21\2\2\u09dd\u014f") + buf.write("\3\2\2\2\u09de\u09df\t\4\2\2\u09df\u09e0\t\22\2\2\u09e0") + buf.write("\u09e1\t\r\2\2\u09e1\u09e2\t\n\2\2\u09e2\u09e3\t\16\2") + buf.write("\2\u09e3\u0151\3\2\2\2\u09e4\u09e5\t\4\2\2\u09e5\u09e6") + buf.write("\t\22\2\2\u09e6\u09e7\t\r\2\2\u09e7\u09e8\t\n\2\2\u09e8") + buf.write("\u09e9\t\5\2\2\u09e9\u0153\3\2\2\2\u09ea\u09eb\t\26\2") + buf.write("\2\u09eb\u09ec\t\2\2\2\u09ec\u09ed\t\5\2\2\u09ed\u09ee") + buf.write("\t\2\2\2\u09ee\u09ef\t\b\2\2\u09ef\u09f0\t\b\2\2\u09f0") + buf.write("\u09f1\t\n\2\2\u09f1\u09f2\t\b\2\2\u09f2\u0155\3\2\2\2") + buf.write("\u09f3\u09f4\t\26\2\2\u09f4\u09f5\t\2\2\2\u09f5\u09f6") + buf.write("\t\5\2\2\u09f6\u09f7\t\7\2\2\u09f7\u09f8\t\n\2\2\u09f8") + buf.write("\u09f9\t\5\2\2\u09f9\u0157\3\2\2\2\u09fa\u09fb\t\26\2") + buf.write("\2\u09fb\u09fc\t\2\2\2\u09fc\u09fd\t\5\2\2\u09fd\u09fe") + buf.write("\t\6\2\2\u09fe\u09ff\t\f\2\2\u09ff\u0a00\t\2\2\2\u0a00") + buf.write("\u0a01\t\b\2\2\u0a01\u0159\3\2\2\2\u0a02\u0a03\t\26\2") + buf.write("\2\u0a03\u0a04\t\2\2\2\u0a04\u0a05\t\5\2\2\u0a05\u0a06") + buf.write("\t\6\2\2\u0a06\u0a07\t\f\2\2\u0a07\u0a08\t\6\2\2\u0a08") + buf.write("\u0a09\t\f\2\2\u0a09\u0a0a\t\4\2\2\u0a0a\u0a0b\t\r\2\2") + buf.write("\u0a0b\u015b\3\2\2\2\u0a0c\u0a0d\t\26\2\2\u0a0d\u0a0e") + buf.write("\t\2\2\2\u0a0e\u0a0f\t\7\2\2\u0a0f\u0a10\t\7\2\2\u0a10") + buf.write("\u0a11\t\f\2\2\u0a11\u0a12\t\r\2\2\u0a12\u0a13\t\21\2") + buf.write("\2\u0a13\u015d\3\2\2\2\u0a14\u0a15\t\26\2\2\u0a15\u0a16") + buf.write("\t\2\2\2\u0a16\u0a17\t\7\2\2\u0a17\u0a18\t\7\2\2\u0a18") + buf.write("\u0a19\t\22\2\2\u0a19\u0a1a\t\4\2\2\u0a1a\u0a1b\t\5\2") + buf.write("\2\u0a1b\u0a1c\t\16\2\2\u0a1c\u015f\3\2\2\2\u0a1d\u0a1e") + buf.write("\t\26\2\2\u0a1e\u0a1f\t\b\2\2\u0a1f\u0a20\t\2\2\2\u0a20") + buf.write("\u0a21\t\r\2\2\u0a21\u0a22\t\7\2\2\u0a22\u0161\3\2\2\2") + buf.write("\u0a23\u0a24\t\26\2\2\u0a24\u0a25\t\4\2\2\u0a25\u0a26") + buf.write("\t\b\2\2\u0a26\u0a27\t\f\2\2\u0a27\u0a28\t\13\2\2\u0a28") + buf.write("\u0a29\t\23\2\2\u0a29\u0163\3\2\2\2\u0a2a\u0a2b\t\26\2") + buf.write("\2\u0a2b\u0a2c\t\5\2\2\u0a2c\u0a2d\t\n\2\2\u0a2d\u0a2e") + buf.write("\t\13\2\2\u0a2e\u0a2f\t\n\2\2\u0a2f\u0a30\t\16\2\2\u0a30") + buf.write("\u0a31\t\f\2\2\u0a31\u0a32\t\r\2\2\u0a32\u0a33\t\21\2") + buf.write("\2\u0a33\u0165\3\2\2\2\u0a34\u0a35\t\26\2\2\u0a35\u0a36") + buf.write("\t\5\2\2\u0a36\u0a37\t\n\2\2\u0a37\u0a38\t\26\2\2\u0a38") + buf.write("\u0a39\t\2\2\2\u0a39\u0a3a\t\5\2\2\u0a3a\u0a3b\t\n\2\2") + buf.write("\u0a3b\u0167\3\2\2\2\u0a3c\u0a3d\t\26\2\2\u0a3d\u0a3e") + buf.write("\t\5\2\2\u0a3e\u0a3f\t\n\2\2\u0a3f\u0a40\t\26\2\2\u0a40") + buf.write("\u0a41\t\2\2\2\u0a41\u0a42\t\5\2\2\u0a42\u0a43\t\n\2\2") + buf.write("\u0a43\u0a44\t\16\2\2\u0a44\u0169\3\2\2\2\u0a45\u0a46") + buf.write("\t\26\2\2\u0a46\u0a47\t\5\2\2\u0a47\u0a48\t\n\2\2\u0a48") + buf.write("\u0a49\t\7\2\2\u0a49\u0a4a\t\n\2\2\u0a4a\u0a4b\t\5\2\2") + buf.write("\u0a4b\u0a4c\t\27\2\2\u0a4c\u0a4d\t\n\2\2\u0a4d\u016b") + buf.write("\3\2\2\2\u0a4e\u0a4f\t\26\2\2\u0a4f\u0a50\t\5\2\2\u0a50") + buf.write("\u0a51\t\f\2\2\u0a51\u0a52\t\4\2\2\u0a52\u0a53\t\5\2\2") + buf.write("\u0a53\u016d\3\2\2\2\u0a54\u0a55\t\26\2\2\u0a55\u0a56") + buf.write("\t\5\2\2\u0a56\u0a57\t\f\2\2\u0a57\u0a58\t\27\2\2\u0a58") + buf.write("\u0a59\t\f\2\2\u0a59\u0a5a\t\b\2\2\u0a5a\u0a5b\t\n\2\2") + buf.write("\u0a5b\u0a5c\t\21\2\2\u0a5c\u0a5d\t\n\2\2\u0a5d\u0a5e") + buf.write("\t\7\2\2\u0a5e\u016f\3\2\2\2\u0a5f\u0a60\t\26\2\2\u0a60") + buf.write("\u0a61\t\5\2\2\u0a61\u0a62\t\4\2\2\u0a62\u0a63\t\13\2") + buf.write("\2\u0a63\u0a64\t\n\2\2\u0a64\u0a65\t\16\2\2\u0a65\u0a66") + buf.write("\t\t\2\2\u0a66\u0a67\t\5\2\2\u0a67\u0a68\t\2\2\2\u0a68") + buf.write("\u0a69\t\b\2\2\u0a69\u0171\3\2\2\2\u0a6a\u0a6b\t\26\2") + buf.write("\2\u0a6b\u0a6c\t\5\2\2\u0a6c\u0a6d\t\4\2\2\u0a6d\u0a6e") + buf.write("\t\13\2\2\u0a6e\u0a6f\t\n\2\2\u0a6f\u0a70\t\16\2\2\u0a70") + buf.write("\u0a71\t\t\2\2\u0a71\u0a72\t\5\2\2\u0a72\u0a73\t\n\2\2") + buf.write("\u0a73\u0173\3\2\2\2\u0a74\u0a75\t\26\2\2\u0a75\u0a76") + buf.write("\t\5\2\2\u0a76\u0a77\t\4\2\2\u0a77\u0a78\t\13\2\2\u0a78") + buf.write("\u0a79\t\n\2\2\u0a79\u0a7a\t\16\2\2\u0a7a\u0a7b\t\t\2") + buf.write("\2\u0a7b\u0a7c\t\5\2\2\u0a7c\u0a7d\t\n\2\2\u0a7d\u0a7e") + buf.write("\t\7\2\2\u0a7e\u0175\3\2\2\2\u0a7f\u0a80\t\26\2\2\u0a80") + buf.write("\u0a81\t\5\2\2\u0a81\u0a82\t\4\2\2\u0a82\u0a83\t\21\2") + buf.write("\2\u0a83\u0a84\t\5\2\2\u0a84\u0a85\t\2\2\2\u0a85\u0a86") + buf.write("\t\17\2\2\u0a86\u0177\3\2\2\2\u0a87\u0a88\t\26\2\2\u0a88") + buf.write("\u0a89\t\t\2\2\u0a89\u0a8a\t\3\2\2\u0a8a\u0a8b\t\b\2\2") + buf.write("\u0a8b\u0a8c\t\f\2\2\u0a8c\u0a8d\t\13\2\2\u0a8d\u0a8e") + buf.write("\t\2\2\2\u0a8e\u0a8f\t\6\2\2\u0a8f\u0a90\t\f\2\2\u0a90") + buf.write("\u0a91\t\4\2\2\u0a91\u0a92\t\r\2\2\u0a92\u0179\3\2\2\2") + buf.write("\u0a93\u0a94\t\33\2\2\u0a94\u0a95\t\t\2\2\u0a95\u0a96") + buf.write("\t\4\2\2\u0a96\u0a97\t\6\2\2\u0a97\u0a98\t\n\2\2\u0a98") + buf.write("\u017b\3\2\2\2\u0a99\u0a9a\t\5\2\2\u0a9a\u0a9b\t\2\2\2") + buf.write("\u0a9b\u0a9c\t\r\2\2\u0a9c\u0a9d\t\21\2\2\u0a9d\u0a9e") + buf.write("\t\n\2\2\u0a9e\u017d\3\2\2\2\u0a9f\u0aa0\t\5\2\2\u0aa0") + buf.write("\u0aa1\t\n\2\2\u0aa1\u0aa2\t\2\2\2\u0aa2\u0aa3\t\16\2") + buf.write("\2\u0aa3\u017f\3\2\2\2\u0aa4\u0aa5\t\5\2\2\u0aa5\u0aa6") + buf.write("\t\n\2\2\u0aa6\u0aa7\t\2\2\2\u0aa7\u0aa8\t\7\2\2\u0aa8") + buf.write("\u0aa9\t\7\2\2\u0aa9\u0aaa\t\f\2\2\u0aaa\u0aab\t\21\2") + buf.write("\2\u0aab\u0aac\t\r\2\2\u0aac\u0181\3\2\2\2\u0aad\u0aae") + buf.write("\t\5\2\2\u0aae\u0aaf\t\n\2\2\u0aaf\u0ab0\t\13\2\2\u0ab0") + buf.write("\u0ab1\t\24\2\2\u0ab1\u0ab2\t\n\2\2\u0ab2\u0ab3\t\13\2") + buf.write("\2\u0ab3\u0ab4\t\25\2\2\u0ab4\u0183\3\2\2\2\u0ab5\u0ab6") + buf.write("\t\5\2\2\u0ab6\u0ab7\t\n\2\2\u0ab7\u0ab8\t\13\2\2\u0ab8") + buf.write("\u0ab9\t\t\2\2\u0ab9\u0aba\t\5\2\2\u0aba\u0abb\t\7\2\2") + buf.write("\u0abb\u0abc\t\f\2\2\u0abc\u0abd\t\27\2\2\u0abd\u0abe") + buf.write("\t\n\2\2\u0abe\u0185\3\2\2\2\u0abf\u0ac0\t\5\2\2\u0ac0") + buf.write("\u0ac1\t\n\2\2\u0ac1\u0ac2\t\20\2\2\u0ac2\u0187\3\2\2") + buf.write("\2\u0ac3\u0ac4\t\5\2\2\u0ac4\u0ac5\t\n\2\2\u0ac5\u0ac6") + buf.write("\t\20\2\2\u0ac6\u0ac7\t\n\2\2\u0ac7\u0ac8\t\5\2\2\u0ac8") + buf.write("\u0ac9\t\n\2\2\u0ac9\u0aca\t\r\2\2\u0aca\u0acb\t\13\2") + buf.write("\2\u0acb\u0acc\t\f\2\2\u0acc\u0acd\t\r\2\2\u0acd\u0ace") + buf.write("\t\21\2\2\u0ace\u0189\3\2\2\2\u0acf\u0ad0\t\5\2\2\u0ad0") + buf.write("\u0ad1\t\n\2\2\u0ad1\u0ad2\t\20\2\2\u0ad2\u0ad3\t\5\2") + buf.write("\2\u0ad3\u0ad4\t\n\2\2\u0ad4\u0ad5\t\7\2\2\u0ad5\u0ad6") + buf.write("\t\24\2\2\u0ad6\u018b\3\2\2\2\u0ad7\u0ad8\t\5\2\2\u0ad8") + buf.write("\u0ad9\t\n\2\2\u0ad9\u0ada\t\f\2\2\u0ada\u0adb\t\r\2\2") + buf.write("\u0adb\u0adc\t\16\2\2\u0adc\u0add\t\n\2\2\u0add\u0ade") + buf.write("\t\30\2\2\u0ade\u018d\3\2\2\2\u0adf\u0ae0\t\5\2\2\u0ae0") + buf.write("\u0ae1\t\n\2\2\u0ae1\u0ae2\t\b\2\2\u0ae2\u0ae3\t\2\2\2") + buf.write("\u0ae3\u0ae4\t\6\2\2\u0ae4\u0ae5\t\f\2\2\u0ae5\u0ae6\t") + buf.write("\27\2\2\u0ae6\u0ae7\t\n\2\2\u0ae7\u018f\3\2\2\2\u0ae8") + buf.write("\u0ae9\t\5\2\2\u0ae9\u0aea\t\n\2\2\u0aea\u0aeb\t\b\2\2") + buf.write("\u0aeb\u0aec\t\n\2\2\u0aec\u0aed\t\2\2\2\u0aed\u0aee\t") + buf.write("\7\2\2\u0aee\u0aef\t\n\2\2\u0aef\u0191\3\2\2\2\u0af0\u0af1") + buf.write("\t\5\2\2\u0af1\u0af2\t\n\2\2\u0af2\u0af3\t\r\2\2\u0af3") + buf.write("\u0af4\t\2\2\2\u0af4\u0af5\t\17\2\2\u0af5\u0af6\t\n\2") + buf.write("\2\u0af6\u0193\3\2\2\2\u0af7\u0af8\t\5\2\2\u0af8\u0af9") + buf.write("\t\n\2\2\u0af9\u0afa\t\26\2\2\u0afa\u0afb\t\n\2\2\u0afb") + buf.write("\u0afc\t\2\2\2\u0afc\u0afd\t\6\2\2\u0afd\u0afe\t\2\2\2") + buf.write("\u0afe\u0aff\t\3\2\2\u0aff\u0b00\t\b\2\2\u0b00\u0b01\t") + buf.write("\n\2\2\u0b01\u0195\3\2\2\2\u0b02\u0b03\t\5\2\2\u0b03\u0b04") + buf.write("\t\n\2\2\u0b04\u0b05\t\26\2\2\u0b05\u0b06\t\b\2\2\u0b06") + buf.write("\u0b07\t\2\2\2\u0b07\u0b08\t\13\2\2\u0b08\u0b09\t\n\2") + buf.write("\2\u0b09\u0197\3\2\2\2\u0b0a\u0b0b\t\5\2\2\u0b0b\u0b0c") + buf.write("\t\n\2\2\u0b0c\u0b0d\t\26\2\2\u0b0d\u0b0e\t\b\2\2\u0b0e") + buf.write("\u0b0f\t\f\2\2\u0b0f\u0b10\t\13\2\2\u0b10\u0b11\t\2\2") + buf.write("\2\u0b11\u0199\3\2\2\2\u0b12\u0b13\t\5\2\2\u0b13\u0b14") + buf.write("\t\n\2\2\u0b14\u0b15\t\7\2\2\u0b15\u0b16\t\n\2\2\u0b16") + buf.write("\u0b17\t\6\2\2\u0b17\u019b\3\2\2\2\u0b18\u0b19\t\5\2\2") + buf.write("\u0b19\u0b1a\t\n\2\2\u0b1a\u0b1b\t\7\2\2\u0b1b\u0b1c\t") + buf.write("\6\2\2\u0b1c\u0b1d\t\2\2\2\u0b1d\u0b1e\t\5\2\2\u0b1e\u0b1f") + buf.write("\t\6\2\2\u0b1f\u019d\3\2\2\2\u0b20\u0b21\t\5\2\2\u0b21") + buf.write("\u0b22\t\n\2\2\u0b22\u0b23\t\7\2\2\u0b23\u0b24\t\6\2\2") + buf.write("\u0b24\u0b25\t\5\2\2\u0b25\u0b26\t\f\2\2\u0b26\u0b27\t") + buf.write("\13\2\2\u0b27\u0b28\t\6\2\2\u0b28\u019f\3\2\2\2\u0b29") + buf.write("\u0b2a\t\5\2\2\u0b2a\u0b2b\t\n\2\2\u0b2b\u0b2c\t\6\2\2") + buf.write("\u0b2c\u0b2d\t\t\2\2\u0b2d\u0b2e\t\5\2\2\u0b2e\u0b2f\t") + buf.write("\r\2\2\u0b2f\u0b30\t\7\2\2\u0b30\u01a1\3\2\2\2\u0b31\u0b32") + buf.write("\t\5\2\2\u0b32\u0b33\t\n\2\2\u0b33\u0b34\t\27\2\2\u0b34") + buf.write("\u0b35\t\4\2\2\u0b35\u0b36\t\25\2\2\u0b36\u0b37\t\n\2") + buf.write("\2\u0b37\u01a3\3\2\2\2\u0b38\u0b39\t\5\2\2\u0b39\u0b3a") + buf.write("\t\4\2\2\u0b3a\u0b3b\t\b\2\2\u0b3b\u0b3c\t\n\2\2\u0b3c") + buf.write("\u01a5\3\2\2\2\u0b3d\u0b3e\t\5\2\2\u0b3e\u0b3f\t\4\2\2") + buf.write("\u0b3f\u0b40\t\b\2\2\u0b40\u0b41\t\b\2\2\u0b41\u0b42\t") + buf.write("\3\2\2\u0b42\u0b43\t\2\2\2\u0b43\u0b44\t\13\2\2\u0b44") + buf.write("\u0b45\t\25\2\2\u0b45\u01a7\3\2\2\2\u0b46\u0b47\t\5\2") + buf.write("\2\u0b47\u0b48\t\4\2\2\u0b48\u0b49\t\b\2\2\u0b49\u0b4a") + buf.write("\t\b\2\2\u0b4a\u0b4b\t\t\2\2\u0b4b\u0b4c\t\26\2\2\u0b4c") + buf.write("\u01a9\3\2\2\2\u0b4d\u0b4e\t\5\2\2\u0b4e\u0b4f\t\4\2\2") + buf.write("\u0b4f\u0b50\t\t\2\2\u0b50\u0b51\t\6\2\2\u0b51\u0b52\t") + buf.write("\f\2\2\u0b52\u0b53\t\r\2\2\u0b53\u0b54\t\n\2\2\u0b54\u01ab") + buf.write("\3\2\2\2\u0b55\u0b56\t\5\2\2\u0b56\u0b57\t\4\2\2\u0b57") + buf.write("\u0b58\t\t\2\2\u0b58\u0b59\t\6\2\2\u0b59\u0b5a\t\f\2\2") + buf.write("\u0b5a\u0b5b\t\r\2\2\u0b5b\u0b5c\t\n\2\2\u0b5c\u0b5d\t") + buf.write("\7\2\2\u0b5d\u01ad\3\2\2\2\u0b5e\u0b5f\t\5\2\2\u0b5f\u0b60") + buf.write("\t\4\2\2\u0b60\u0b61\t\22\2\2\u0b61\u0b62\t\7\2\2\u0b62") + buf.write("\u01af\3\2\2\2\u0b63\u0b64\t\5\2\2\u0b64\u0b65\t\t\2\2") + buf.write("\u0b65\u0b66\t\b\2\2\u0b66\u0b67\t\n\2\2\u0b67\u01b1\3") + buf.write("\2\2\2\u0b68\u0b69\t\7\2\2\u0b69\u0b6a\t\2\2\2\u0b6a\u0b6b") + buf.write("\t\27\2\2\u0b6b\u0b6c\t\n\2\2\u0b6c\u0b6d\t\26\2\2\u0b6d") + buf.write("\u0b6e\t\4\2\2\u0b6e\u0b6f\t\f\2\2\u0b6f\u0b70\t\r\2\2") + buf.write("\u0b70\u0b71\t\6\2\2\u0b71\u01b3\3\2\2\2\u0b72\u0b73\t") + buf.write("\7\2\2\u0b73\u0b74\t\13\2\2\u0b74\u0b75\t\24\2\2\u0b75") + buf.write("\u0b76\t\n\2\2\u0b76\u0b77\t\17\2\2\u0b77\u0b78\t\2\2") + buf.write("\2\u0b78\u01b5\3\2\2\2\u0b79\u0b7a\t\7\2\2\u0b7a\u0b7b") + buf.write("\t\13\2\2\u0b7b\u0b7c\t\24\2\2\u0b7c\u0b7d\t\n\2\2\u0b7d") + buf.write("\u0b7e\t\17\2\2\u0b7e\u0b7f\t\2\2\2\u0b7f\u0b80\t\7\2") + buf.write("\2\u0b80\u01b7\3\2\2\2\u0b81\u0b82\t\7\2\2\u0b82\u0b83") + buf.write("\t\13\2\2\u0b83\u0b84\t\5\2\2\u0b84\u0b85\t\4\2\2\u0b85") + buf.write("\u0b86\t\b\2\2\u0b86\u0b87\t\b\2\2\u0b87\u01b9\3\2\2\2") + buf.write("\u0b88\u0b89\t\7\2\2\u0b89\u0b8a\t\n\2\2\u0b8a\u0b8b\t") + buf.write("\2\2\2\u0b8b\u0b8c\t\5\2\2\u0b8c\u0b8d\t\13\2\2\u0b8d") + buf.write("\u0b8e\t\24\2\2\u0b8e\u01bb\3\2\2\2\u0b8f\u0b90\t\7\2") + buf.write("\2\u0b90\u0b91\t\n\2\2\u0b91\u0b92\t\13\2\2\u0b92\u0b93") + buf.write("\t\4\2\2\u0b93\u0b94\t\r\2\2\u0b94\u0b95\t\16\2\2\u0b95") + buf.write("\u01bd\3\2\2\2\u0b96\u0b97\t\7\2\2\u0b97\u0b98\t\n\2\2") + buf.write("\u0b98\u0b99\t\13\2\2\u0b99\u0b9a\t\t\2\2\u0b9a\u0b9b") + buf.write("\t\5\2\2\u0b9b\u0b9c\t\f\2\2\u0b9c\u0b9d\t\6\2\2\u0b9d") + buf.write("\u0b9e\t\23\2\2\u0b9e\u01bf\3\2\2\2\u0b9f\u0ba0\t\7\2") + buf.write("\2\u0ba0\u0ba1\t\n\2\2\u0ba1\u0ba2\t\33\2\2\u0ba2\u0ba3") + buf.write("\t\t\2\2\u0ba3\u0ba4\t\n\2\2\u0ba4\u0ba5\t\r\2\2\u0ba5") + buf.write("\u0ba6\t\13\2\2\u0ba6\u0ba7\t\n\2\2\u0ba7\u01c1\3\2\2") + buf.write("\2\u0ba8\u0ba9\t\7\2\2\u0ba9\u0baa\t\n\2\2\u0baa\u0bab") + buf.write("\t\33\2\2\u0bab\u0bac\t\t\2\2\u0bac\u0bad\t\n\2\2\u0bad") + buf.write("\u0bae\t\r\2\2\u0bae\u0baf\t\13\2\2\u0baf\u0bb0\t\n\2") + buf.write("\2\u0bb0\u0bb1\t\7\2\2\u0bb1\u01c3\3\2\2\2\u0bb2\u0bb3") + buf.write("\t\7\2\2\u0bb3\u0bb4\t\n\2\2\u0bb4\u0bb5\t\5\2\2\u0bb5") + buf.write("\u0bb6\t\f\2\2\u0bb6\u0bb7\t\2\2\2\u0bb7\u0bb8\t\b\2\2") + buf.write("\u0bb8\u0bb9\t\f\2\2\u0bb9\u0bba\t\31\2\2\u0bba\u0bbb") + buf.write("\t\2\2\2\u0bbb\u0bbc\t\3\2\2\u0bbc\u0bbd\t\b\2\2\u0bbd") + buf.write("\u0bbe\t\n\2\2\u0bbe\u01c5\3\2\2\2\u0bbf\u0bc0\t\7\2\2") + buf.write("\u0bc0\u0bc1\t\n\2\2\u0bc1\u0bc2\t\5\2\2\u0bc2\u0bc3\t") + buf.write("\27\2\2\u0bc3\u0bc4\t\n\2\2\u0bc4\u0bc5\t\5\2\2\u0bc5") + buf.write("\u01c7\3\2\2\2\u0bc6\u0bc7\t\7\2\2\u0bc7\u0bc8\t\n\2\2") + buf.write("\u0bc8\u0bc9\t\7\2\2\u0bc9\u0bca\t\7\2\2\u0bca\u0bcb\t") + buf.write("\f\2\2\u0bcb\u0bcc\t\4\2\2\u0bcc\u0bcd\t\r\2\2\u0bcd\u01c9") + buf.write("\3\2\2\2\u0bce\u0bcf\t\7\2\2\u0bcf\u0bd0\t\n\2\2\u0bd0") + buf.write("\u0bd1\t\6\2\2\u0bd1\u01cb\3\2\2\2\u0bd2\u0bd3\t\7\2\2") + buf.write("\u0bd3\u0bd4\t\n\2\2\u0bd4\u0bd5\t\6\2\2\u0bd5\u0bd6\t") + buf.write("\7\2\2\u0bd6\u01cd\3\2\2\2\u0bd7\u0bd8\t\7\2\2\u0bd8\u0bd9") + buf.write("\t\24\2\2\u0bd9\u0bda\t\2\2\2\u0bda\u0bdb\t\5\2\2\u0bdb") + buf.write("\u0bdc\t\n\2\2\u0bdc\u01cf\3\2\2\2\u0bdd\u0bde\t\7\2\2") + buf.write("\u0bde\u0bdf\t\24\2\2\u0bdf\u0be0\t\4\2\2\u0be0\u0be1") + buf.write("\t\22\2\2\u0be1\u01d1\3\2\2\2\u0be2\u0be3\t\7\2\2\u0be3") + buf.write("\u0be4\t\f\2\2\u0be4\u0be5\t\17\2\2\u0be5\u0be6\t\26\2") + buf.write("\2\u0be6\u0be7\t\b\2\2\u0be7\u0be8\t\n\2\2\u0be8\u01d3") + buf.write("\3\2\2\2\u0be9\u0bea\t\7\2\2\u0bea\u0beb\t\25\2\2\u0beb") + buf.write("\u0bec\t\f\2\2\u0bec\u0bed\t\26\2\2\u0bed\u01d5\3\2\2") + buf.write("\2\u0bee\u0bef\t\7\2\2\u0bef\u0bf0\t\r\2\2\u0bf0\u0bf1") + buf.write("\t\2\2\2\u0bf1\u0bf2\t\26\2\2\u0bf2\u0bf3\t\7\2\2\u0bf3") + buf.write("\u0bf4\t\24\2\2\u0bf4\u0bf5\t\4\2\2\u0bf5\u0bf6\t\6\2") + buf.write("\2\u0bf6\u01d7\3\2\2\2\u0bf7\u0bf8\t\7\2\2\u0bf8\u0bf9") + buf.write("\t\33\2\2\u0bf9\u0bfa\t\b\2\2\u0bfa\u01d9\3\2\2\2\u0bfb") + buf.write("\u0bfc\t\7\2\2\u0bfc\u0bfd\t\6\2\2\u0bfd\u0bfe\t\2\2\2") + buf.write("\u0bfe\u0bff\t\3\2\2\u0bff\u0c00\t\b\2\2\u0c00\u0c01\t") + buf.write("\n\2\2\u0c01\u01db\3\2\2\2\u0c02\u0c03\t\7\2\2\u0c03\u0c04") + buf.write("\t\6\2\2\u0c04\u0c05\t\2\2\2\u0c05\u0c06\t\r\2\2\u0c06") + buf.write("\u0c07\t\16\2\2\u0c07\u0c08\t\2\2\2\u0c08\u0c09\t\b\2") + buf.write("\2\u0c09\u0c0a\t\4\2\2\u0c0a\u0c0b\t\r\2\2\u0c0b\u0c0c") + buf.write("\t\n\2\2\u0c0c\u01dd\3\2\2\2\u0c0d\u0c0e\t\7\2\2\u0c0e") + buf.write("\u0c0f\t\6\2\2\u0c0f\u0c10\t\2\2\2\u0c10\u0c11\t\5\2\2") + buf.write("\u0c11\u0c12\t\6\2\2\u0c12\u01df\3\2\2\2\u0c13\u0c14\t") + buf.write("\7\2\2\u0c14\u0c15\t\6\2\2\u0c15\u0c16\t\2\2\2\u0c16\u0c17") + buf.write("\t\6\2\2\u0c17\u0c18\t\n\2\2\u0c18\u0c19\t\17\2\2\u0c19") + buf.write("\u0c1a\t\n\2\2\u0c1a\u0c1b\t\r\2\2\u0c1b\u0c1c\t\6\2\2") + buf.write("\u0c1c\u01e1\3\2\2\2\u0c1d\u0c1e\t\7\2\2\u0c1e\u0c1f\t") + buf.write("\6\2\2\u0c1f\u0c20\t\2\2\2\u0c20\u0c21\t\6\2\2\u0c21\u0c22") + buf.write("\t\f\2\2\u0c22\u0c23\t\7\2\2\u0c23\u0c24\t\6\2\2\u0c24") + buf.write("\u0c25\t\f\2\2\u0c25\u0c26\t\13\2\2\u0c26\u0c27\t\7\2") + buf.write("\2\u0c27\u01e3\3\2\2\2\u0c28\u0c29\t\7\2\2\u0c29\u0c2a") + buf.write("\t\6\2\2\u0c2a\u0c2b\t\16\2\2\u0c2b\u0c2c\t\f\2\2\u0c2c") + buf.write("\u0c2d\t\r\2\2\u0c2d\u01e5\3\2\2\2\u0c2e\u0c2f\t\7\2\2") + buf.write("\u0c2f\u0c30\t\6\2\2\u0c30\u0c31\t\16\2\2\u0c31\u0c32") + buf.write("\t\4\2\2\u0c32\u0c33\t\t\2\2\u0c33\u0c34\t\6\2\2\u0c34") + buf.write("\u01e7\3\2\2\2\u0c35\u0c36\t\7\2\2\u0c36\u0c37\t\6\2\2") + buf.write("\u0c37\u0c38\t\4\2\2\u0c38\u0c39\t\5\2\2\u0c39\u0c3a\t") + buf.write("\2\2\2\u0c3a\u0c3b\t\21\2\2\u0c3b\u0c3c\t\n\2\2\u0c3c") + buf.write("\u01e9\3\2\2\2\u0c3d\u0c3e\t\7\2\2\u0c3e\u0c3f\t\6\2\2") + buf.write("\u0c3f\u0c40\t\4\2\2\u0c40\u0c41\t\5\2\2\u0c41\u0c42\t") + buf.write("\n\2\2\u0c42\u0c43\t\16\2\2\u0c43\u01eb\3\2\2\2\u0c44") + buf.write("\u0c45\t\7\2\2\u0c45\u0c46\t\6\2\2\u0c46\u0c47\t\5\2\2") + buf.write("\u0c47\u0c48\t\f\2\2\u0c48\u0c49\t\13\2\2\u0c49\u0c4a") + buf.write("\t\6\2\2\u0c4a\u01ed\3\2\2\2\u0c4b\u0c4c\t\7\2\2\u0c4c") + buf.write("\u0c4d\t\6\2\2\u0c4d\u0c4e\t\5\2\2\u0c4e\u0c4f\t\f\2\2") + buf.write("\u0c4f\u0c50\t\26\2\2\u0c50\u01ef\3\2\2\2\u0c51\u0c52") + buf.write("\t\7\2\2\u0c52\u0c53\t\t\2\2\u0c53\u0c54\t\3\2\2\u0c54") + buf.write("\u0c55\t\7\2\2\u0c55\u0c56\t\13\2\2\u0c56\u0c57\t\5\2") + buf.write("\2\u0c57\u0c58\t\f\2\2\u0c58\u0c59\t\26\2\2\u0c59\u0c5a") + buf.write("\t\6\2\2\u0c5a\u0c5b\t\f\2\2\u0c5b\u0c5c\t\4\2\2\u0c5c") + buf.write("\u0c5d\t\r\2\2\u0c5d\u01f1\3\2\2\2\u0c5e\u0c5f\t\7\2\2") + buf.write("\u0c5f\u0c60\t\t\2\2\u0c60\u0c61\t\26\2\2\u0c61\u0c62") + buf.write("\t\26\2\2\u0c62\u0c63\t\4\2\2\u0c63\u0c64\t\5\2\2\u0c64") + buf.write("\u0c65\t\6\2\2\u0c65\u01f3\3\2\2\2\u0c66\u0c67\t\7\2\2") + buf.write("\u0c67\u0c68\t\23\2\2\u0c68\u0c69\t\7\2\2\u0c69\u0c6a") + buf.write("\t\f\2\2\u0c6a\u0c6b\t\16\2\2\u0c6b\u01f5\3\2\2\2\u0c6c") + buf.write("\u0c6d\t\7\2\2\u0c6d\u0c6e\t\23\2\2\u0c6e\u0c6f\t\7\2") + buf.write("\2\u0c6f\u0c70\t\6\2\2\u0c70\u0c71\t\n\2\2\u0c71\u0c72") + buf.write("\t\17\2\2\u0c72\u01f7\3\2\2\2\u0c73\u0c74\t\6\2\2\u0c74") + buf.write("\u0c75\t\2\2\2\u0c75\u0c76\t\3\2\2\u0c76\u0c77\t\b\2\2") + buf.write("\u0c77\u0c78\t\n\2\2\u0c78\u0c79\t\7\2\2\u0c79\u01f9\3") + buf.write("\2\2\2\u0c7a\u0c7b\t\6\2\2\u0c7b\u0c7c\t\2\2\2\u0c7c\u0c7d") + buf.write("\t\3\2\2\u0c7d\u0c7e\t\b\2\2\u0c7e\u0c7f\t\n\2\2\u0c7f") + buf.write("\u0c80\t\7\2\2\u0c80\u0c81\t\26\2\2\u0c81\u0c82\t\2\2") + buf.write("\2\u0c82\u0c83\t\13\2\2\u0c83\u0c84\t\n\2\2\u0c84\u01fb") + buf.write("\3\2\2\2\u0c85\u0c86\t\6\2\2\u0c86\u0c87\t\n\2\2\u0c87") + buf.write("\u0c88\t\17\2\2\u0c88\u0c89\t\26\2\2\u0c89\u01fd\3\2\2") + buf.write("\2\u0c8a\u0c8b\t\6\2\2\u0c8b\u0c8c\t\n\2\2\u0c8c\u0c8d") + buf.write("\t\17\2\2\u0c8d\u0c8e\t\26\2\2\u0c8e\u0c8f\t\b\2\2\u0c8f") + buf.write("\u0c90\t\2\2\2\u0c90\u0c91\t\6\2\2\u0c91\u0c92\t\n\2\2") + buf.write("\u0c92\u01ff\3\2\2\2\u0c93\u0c94\t\6\2\2\u0c94\u0c95\t") + buf.write("\n\2\2\u0c95\u0c96\t\17\2\2\u0c96\u0c97\t\26\2\2\u0c97") + buf.write("\u0c98\t\4\2\2\u0c98\u0c99\t\5\2\2\u0c99\u0c9a\t\2\2\2") + buf.write("\u0c9a\u0c9b\t\5\2\2\u0c9b\u0c9c\t\23\2\2\u0c9c\u0201") + buf.write("\3\2\2\2\u0c9d\u0c9e\t\6\2\2\u0c9e\u0c9f\t\n\2\2\u0c9f") + buf.write("\u0ca0\t\30\2\2\u0ca0\u0ca1\t\6\2\2\u0ca1\u0203\3\2\2") + buf.write("\2\u0ca2\u0ca3\t\6\2\2\u0ca3\u0ca4\t\f\2\2\u0ca4\u0ca5") + buf.write("\t\n\2\2\u0ca5\u0ca6\t\7\2\2\u0ca6\u0205\3\2\2\2\u0ca7") + buf.write("\u0ca8\t\6\2\2\u0ca8\u0ca9\t\5\2\2\u0ca9\u0caa\t\2\2\2") + buf.write("\u0caa\u0cab\t\r\2\2\u0cab\u0cac\t\7\2\2\u0cac\u0cad\t") + buf.write("\2\2\2\u0cad\u0cae\t\13\2\2\u0cae\u0caf\t\6\2\2\u0caf") + buf.write("\u0cb0\t\f\2\2\u0cb0\u0cb1\t\4\2\2\u0cb1\u0cb2\t\r\2\2") + buf.write("\u0cb2\u0207\3\2\2\2\u0cb3\u0cb4\t\6\2\2\u0cb4\u0cb5\t") + buf.write("\5\2\2\u0cb5\u0cb6\t\2\2\2\u0cb6\u0cb7\t\r\2\2\u0cb7\u0cb8") + buf.write("\t\7\2\2\u0cb8\u0cb9\t\20\2\2\u0cb9\u0cba\t\4\2\2\u0cba") + buf.write("\u0cbb\t\5\2\2\u0cbb\u0cbc\t\17\2\2\u0cbc\u0209\3\2\2") + buf.write("\2\u0cbd\u0cbe\t\6\2\2\u0cbe\u0cbf\t\5\2\2\u0cbf\u0cc0") + buf.write("\t\f\2\2\u0cc0\u0cc1\t\21\2\2\u0cc1\u0cc2\t\21\2\2\u0cc2") + buf.write("\u0cc3\t\n\2\2\u0cc3\u0cc4\t\5\2\2\u0cc4\u020b\3\2\2\2") + buf.write("\u0cc5\u0cc6\t\6\2\2\u0cc6\u0cc7\t\5\2\2\u0cc7\u0cc8\t") + buf.write("\t\2\2\u0cc8\u0cc9\t\r\2\2\u0cc9\u0cca\t\13\2\2\u0cca") + buf.write("\u0ccb\t\2\2\2\u0ccb\u0ccc\t\6\2\2\u0ccc\u0ccd\t\n\2\2") + buf.write("\u0ccd\u020d\3\2\2\2\u0cce\u0ccf\t\6\2\2\u0ccf\u0cd0\t") + buf.write("\5\2\2\u0cd0\u0cd1\t\t\2\2\u0cd1\u0cd2\t\7\2\2\u0cd2\u0cd3") + buf.write("\t\6\2\2\u0cd3\u0cd4\t\n\2\2\u0cd4\u0cd5\t\16\2\2\u0cd5") + buf.write("\u020f\3\2\2\2\u0cd6\u0cd7\t\6\2\2\u0cd7\u0cd8\t\23\2") + buf.write("\2\u0cd8\u0cd9\t\26\2\2\u0cd9\u0cda\t\n\2\2\u0cda\u0211") + buf.write("\3\2\2\2\u0cdb\u0cdc\t\6\2\2\u0cdc\u0cdd\t\23\2\2\u0cdd") + buf.write("\u0cde\t\26\2\2\u0cde\u0cdf\t\n\2\2\u0cdf\u0ce0\t\7\2") + buf.write("\2\u0ce0\u0213\3\2\2\2\u0ce1\u0ce2\t\t\2\2\u0ce2\u0ce3") + buf.write("\t\r\2\2\u0ce3\u0ce4\t\3\2\2\u0ce4\u0ce5\t\4\2\2\u0ce5") + buf.write("\u0ce6\t\t\2\2\u0ce6\u0ce7\t\r\2\2\u0ce7\u0ce8\t\16\2") + buf.write("\2\u0ce8\u0ce9\t\n\2\2\u0ce9\u0cea\t\16\2\2\u0cea\u0215") + buf.write("\3\2\2\2\u0ceb\u0cec\t\t\2\2\u0cec\u0ced\t\r\2\2\u0ced") + buf.write("\u0cee\t\13\2\2\u0cee\u0cef\t\4\2\2\u0cef\u0cf0\t\17\2") + buf.write("\2\u0cf0\u0cf1\t\17\2\2\u0cf1\u0cf2\t\f\2\2\u0cf2\u0cf3") + buf.write("\t\6\2\2\u0cf3\u0cf4\t\6\2\2\u0cf4\u0cf5\t\n\2\2\u0cf5") + buf.write("\u0cf6\t\16\2\2\u0cf6\u0217\3\2\2\2\u0cf7\u0cf8\t\t\2") + buf.write("\2\u0cf8\u0cf9\t\r\2\2\u0cf9\u0cfa\t\n\2\2\u0cfa\u0cfb") + buf.write("\t\r\2\2\u0cfb\u0cfc\t\13\2\2\u0cfc\u0cfd\t\5\2\2\u0cfd") + buf.write("\u0cfe\t\23\2\2\u0cfe\u0cff\t\26\2\2\u0cff\u0d00\t\6\2") + buf.write("\2\u0d00\u0d01\t\n\2\2\u0d01\u0d02\t\16\2\2\u0d02\u0219") + buf.write("\3\2\2\2\u0d03\u0d04\t\t\2\2\u0d04\u0d05\t\r\2\2\u0d05") + buf.write("\u0d06\t\25\2\2\u0d06\u0d07\t\r\2\2\u0d07\u0d08\t\4\2") + buf.write("\2\u0d08\u0d09\t\22\2\2\u0d09\u0d0a\t\r\2\2\u0d0a\u021b") + buf.write("\3\2\2\2\u0d0b\u0d0c\t\t\2\2\u0d0c\u0d0d\t\r\2\2\u0d0d") + buf.write("\u0d0e\t\b\2\2\u0d0e\u0d0f\t\f\2\2\u0d0f\u0d10\t\7\2\2") + buf.write("\u0d10\u0d11\t\6\2\2\u0d11\u0d12\t\n\2\2\u0d12\u0d13\t") + buf.write("\r\2\2\u0d13\u021d\3\2\2\2\u0d14\u0d15\t\t\2\2\u0d15\u0d16") + buf.write("\t\r\2\2\u0d16\u0d17\t\b\2\2\u0d17\u0d18\t\4\2\2\u0d18") + buf.write("\u0d19\t\21\2\2\u0d19\u0d1a\t\21\2\2\u0d1a\u0d1b\t\n\2") + buf.write("\2\u0d1b\u0d1c\t\16\2\2\u0d1c\u021f\3\2\2\2\u0d1d\u0d1e") + buf.write("\t\t\2\2\u0d1e\u0d1f\t\r\2\2\u0d1f\u0d20\t\6\2\2\u0d20") + buf.write("\u0d21\t\f\2\2\u0d21\u0d22\t\b\2\2\u0d22\u0221\3\2\2\2") + buf.write("\u0d23\u0d24\t\t\2\2\u0d24\u0d25\t\26\2\2\u0d25\u0d26") + buf.write("\t\16\2\2\u0d26\u0d27\t\2\2\2\u0d27\u0d28\t\6\2\2\u0d28") + buf.write("\u0d29\t\n\2\2\u0d29\u0223\3\2\2\2\u0d2a\u0d2b\t\27\2") + buf.write("\2\u0d2b\u0d2c\t\2\2\2\u0d2c\u0d2d\t\13\2\2\u0d2d\u0d2e") + buf.write("\t\t\2\2\u0d2e\u0d2f\t\t\2\2\u0d2f\u0d30\t\17\2\2\u0d30") + buf.write("\u0225\3\2\2\2\u0d31\u0d32\t\27\2\2\u0d32\u0d33\t\2\2") + buf.write("\2\u0d33\u0d34\t\b\2\2\u0d34\u0d35\t\f\2\2\u0d35\u0d36") + buf.write("\t\16\2\2\u0d36\u0227\3\2\2\2\u0d37\u0d38\t\27\2\2\u0d38") + buf.write("\u0d39\t\2\2\2\u0d39\u0d3a\t\b\2\2\u0d3a\u0d3b\t\f\2\2") + buf.write("\u0d3b\u0d3c\t\16\2\2\u0d3c\u0d3d\t\2\2\2\u0d3d\u0d3e") + buf.write("\t\6\2\2\u0d3e\u0d3f\t\n\2\2\u0d3f\u0229\3\2\2\2\u0d40") + buf.write("\u0d41\t\27\2\2\u0d41\u0d42\t\2\2\2\u0d42\u0d43\t\b\2") + buf.write("\2\u0d43\u0d44\t\f\2\2\u0d44\u0d45\t\16\2\2\u0d45\u0d46") + buf.write("\t\2\2\2\u0d46\u0d47\t\6\2\2\u0d47\u0d48\t\4\2\2\u0d48") + buf.write("\u0d49\t\5\2\2\u0d49\u022b\3\2\2\2\u0d4a\u0d4b\t\27\2") + buf.write("\2\u0d4b\u0d4c\t\2\2\2\u0d4c\u0d4d\t\b\2\2\u0d4d\u0d4e") + buf.write("\t\t\2\2\u0d4e\u0d4f\t\n\2\2\u0d4f\u022d\3\2\2\2\u0d50") + buf.write("\u0d51\t\27\2\2\u0d51\u0d52\t\2\2\2\u0d52\u0d53\t\5\2") + buf.write("\2\u0d53\u0d54\t\23\2\2\u0d54\u0d55\t\f\2\2\u0d55\u0d56") + buf.write("\t\r\2\2\u0d56\u0d57\t\21\2\2\u0d57\u022f\3\2\2\2\u0d58") + buf.write("\u0d59\t\27\2\2\u0d59\u0d5a\t\n\2\2\u0d5a\u0d5b\t\5\2") + buf.write("\2\u0d5b\u0d5c\t\7\2\2\u0d5c\u0d5d\t\f\2\2\u0d5d\u0d5e") + buf.write("\t\4\2\2\u0d5e\u0d5f\t\r\2\2\u0d5f\u0231\3\2\2\2\u0d60") + buf.write("\u0d61\t\27\2\2\u0d61\u0d62\t\f\2\2\u0d62\u0d63\t\n\2") + buf.write("\2\u0d63\u0d64\t\22\2\2\u0d64\u0233\3\2\2\2\u0d65\u0d66") + buf.write("\t\27\2\2\u0d66\u0d67\t\f\2\2\u0d67\u0d68\t\n\2\2\u0d68") + buf.write("\u0d69\t\22\2\2\u0d69\u0d6a\t\7\2\2\u0d6a\u0235\3\2\2") + buf.write("\2\u0d6b\u0d6c\t\27\2\2\u0d6c\u0d6d\t\4\2\2\u0d6d\u0d6e") + buf.write("\t\b\2\2\u0d6e\u0d6f\t\2\2\2\u0d6f\u0d70\t\6\2\2\u0d70") + buf.write("\u0d71\t\f\2\2\u0d71\u0d72\t\b\2\2\u0d72\u0d73\t\n\2\2") + buf.write("\u0d73\u0237\3\2\2\2\u0d74\u0d75\t\22\2\2\u0d75\u0d76") + buf.write("\t\24\2\2\u0d76\u0d77\t\f\2\2\u0d77\u0d78\t\6\2\2\u0d78") + buf.write("\u0d79\t\n\2\2\u0d79\u0d7a\t\7\2\2\u0d7a\u0d7b\t\26\2") + buf.write("\2\u0d7b\u0d7c\t\2\2\2\u0d7c\u0d7d\t\13\2\2\u0d7d\u0d7e") + buf.write("\t\n\2\2\u0d7e\u0239\3\2\2\2\u0d7f\u0d80\t\22\2\2\u0d80") + buf.write("\u0d81\t\f\2\2\u0d81\u0d82\t\6\2\2\u0d82\u0d83\t\24\2") + buf.write("\2\u0d83\u0d84\t\f\2\2\u0d84\u0d85\t\r\2\2\u0d85\u023b") + buf.write("\3\2\2\2\u0d86\u0d87\t\22\2\2\u0d87\u0d88\t\f\2\2\u0d88") + buf.write("\u0d89\t\6\2\2\u0d89\u0d8a\t\24\2\2\u0d8a\u0d8b\t\4\2") + buf.write("\2\u0d8b\u0d8c\t\t\2\2\u0d8c\u0d8d\t\6\2\2\u0d8d\u023d") + buf.write("\3\2\2\2\u0d8e\u0d8f\t\22\2\2\u0d8f\u0d90\t\4\2\2\u0d90") + buf.write("\u0d91\t\5\2\2\u0d91\u0d92\t\25\2\2\u0d92\u023f\3\2\2") + buf.write("\2\u0d93\u0d94\t\22\2\2\u0d94\u0d95\t\5\2\2\u0d95\u0d96") + buf.write("\t\2\2\2\u0d96\u0d97\t\26\2\2\u0d97\u0d98\t\26\2\2\u0d98") + buf.write("\u0d99\t\n\2\2\u0d99\u0d9a\t\5\2\2\u0d9a\u0241\3\2\2\2") + buf.write("\u0d9b\u0d9c\t\22\2\2\u0d9c\u0d9d\t\5\2\2\u0d9d\u0d9e") + buf.write("\t\f\2\2\u0d9e\u0d9f\t\6\2\2\u0d9f\u0da0\t\n\2\2\u0da0") + buf.write("\u0243\3\2\2\2\u0da1\u0da2\t\30\2\2\u0da2\u0da3\t\17\2") + buf.write("\2\u0da3\u0da4\t\b\2\2\u0da4\u0245\3\2\2\2\u0da5\u0da6") + buf.write("\t\23\2\2\u0da6\u0da7\t\n\2\2\u0da7\u0da8\t\2\2\2\u0da8") + buf.write("\u0da9\t\5\2\2\u0da9\u0247\3\2\2\2\u0daa\u0dab\t\23\2") + buf.write("\2\u0dab\u0dac\t\n\2\2\u0dac\u0dad\t\7\2\2\u0dad\u0249") + buf.write("\3\2\2\2\u0dae\u0daf\t\31\2\2\u0daf\u0db0\t\4\2\2\u0db0") + buf.write("\u0db1\t\r\2\2\u0db1\u0db2\t\n\2\2\u0db2\u024b\3\2\2\2") + buf.write("\u0db3\u0db4\t\3\2\2\u0db4\u0db5\t\n\2\2\u0db5\u0db6\t") + buf.write("\6\2\2\u0db6\u0db7\t\22\2\2\u0db7\u0db8\t\n\2\2\u0db8") + buf.write("\u0db9\t\n\2\2\u0db9\u0dba\t\r\2\2\u0dba\u024d\3\2\2\2") + buf.write("\u0dbb\u0dbc\t\3\2\2\u0dbc\u0dbd\t\f\2\2\u0dbd\u0dbe\t") + buf.write("\21\2\2\u0dbe\u0dbf\t\f\2\2\u0dbf\u0dc0\t\r\2\2\u0dc0") + buf.write("\u0dc1\t\6\2\2\u0dc1\u024f\3\2\2\2\u0dc2\u0dc3\t\3\2\2") + buf.write("\u0dc3\u0dc4\t\f\2\2\u0dc4\u0dc5\t\6\2\2\u0dc5\u0251\3") + buf.write("\2\2\2\u0dc6\u0dc7\t\3\2\2\u0dc7\u0dc8\t\4\2\2\u0dc8\u0dc9") + buf.write("\t\4\2\2\u0dc9\u0dca\t\b\2\2\u0dca\u0dcb\t\n\2\2\u0dcb") + buf.write("\u0dcc\t\2\2\2\u0dcc\u0dcd\t\r\2\2\u0dcd\u0253\3\2\2\2") + buf.write("\u0dce\u0dcf\t\13\2\2\u0dcf\u0dd0\t\24\2\2\u0dd0\u0dd1") + buf.write("\t\2\2\2\u0dd1\u0dd2\t\5\2\2\u0dd2\u0255\3\2\2\2\u0dd3") + buf.write("\u0dd4\t\13\2\2\u0dd4\u0dd5\t\24\2\2\u0dd5\u0dd6\t\2\2") + buf.write("\2\u0dd6\u0dd7\t\5\2\2\u0dd7\u0dd8\t\2\2\2\u0dd8\u0dd9") + buf.write("\t\13\2\2\u0dd9\u0dda\t\6\2\2\u0dda\u0ddb\t\n\2\2\u0ddb") + buf.write("\u0ddc\t\5\2\2\u0ddc\u0257\3\2\2\2\u0ddd\u0dde\t\13\2") + buf.write("\2\u0dde\u0ddf\t\4\2\2\u0ddf\u0de0\t\2\2\2\u0de0\u0de1") + buf.write("\t\b\2\2\u0de1\u0de2\t\n\2\2\u0de2\u0de3\t\7\2\2\u0de3") + buf.write("\u0de4\t\13\2\2\u0de4\u0de5\t\n\2\2\u0de5\u0259\3\2\2") + buf.write("\2\u0de6\u0de7\t\16\2\2\u0de7\u0de8\t\n\2\2\u0de8\u0de9") + buf.write("\t\13\2\2\u0de9\u025b\3\2\2\2\u0dea\u0deb\t\16\2\2\u0deb") + buf.write("\u0dec\t\n\2\2\u0dec\u0ded\t\13\2\2\u0ded\u0dee\t\f\2") + buf.write("\2\u0dee\u0def\t\17\2\2\u0def\u0df0\t\2\2\2\u0df0\u0df1") + buf.write("\t\b\2\2\u0df1\u025d\3\2\2\2\u0df2\u0df3\t\n\2\2\u0df3") + buf.write("\u0df4\t\30\2\2\u0df4\u0df5\t\f\2\2\u0df5\u0df6\t\7\2") + buf.write("\2\u0df6\u0df7\t\6\2\2\u0df7\u0df8\t\7\2\2\u0df8\u025f") + buf.write("\3\2\2\2\u0df9\u0dfa\t\n\2\2\u0dfa\u0dfb\t\30\2\2\u0dfb") + buf.write("\u0dfc\t\6\2\2\u0dfc\u0dfd\t\5\2\2\u0dfd\u0dfe\t\2\2\2") + buf.write("\u0dfe\u0dff\t\13\2\2\u0dff\u0e00\t\6\2\2\u0e00\u0261") + buf.write("\3\2\2\2\u0e01\u0e02\t\20\2\2\u0e02\u0e03\t\b\2\2\u0e03") + buf.write("\u0e04\t\4\2\2\u0e04\u0e05\t\2\2\2\u0e05\u0e06\t\6\2\2") + buf.write("\u0e06\u0263\3\2\2\2\u0e07\u0e08\t\21\2\2\u0e08\u0e09") + buf.write("\t\5\2\2\u0e09\u0e0a\t\n\2\2\u0e0a\u0e0b\t\2\2\2\u0e0b") + buf.write("\u0e0c\t\6\2\2\u0e0c\u0e0d\t\n\2\2\u0e0d\u0e0e\t\7\2\2") + buf.write("\u0e0e\u0e0f\t\6\2\2\u0e0f\u0265\3\2\2\2\u0e10\u0e11\t") + buf.write("\21\2\2\u0e11\u0e12\t\5\2\2\u0e12\u0e13\t\4\2\2\u0e13") + buf.write("\u0e14\t\t\2\2\u0e14\u0e15\t\26\2\2\u0e15\u0e16\t\f\2") + buf.write("\2\u0e16\u0e17\t\r\2\2\u0e17\u0e18\t\21\2\2\u0e18\u0267") + buf.write("\3\2\2\2\u0e19\u0e1a\t\f\2\2\u0e1a\u0e1b\t\r\2\2\u0e1b") + buf.write("\u0e1c\t\4\2\2\u0e1c\u0e1d\t\t\2\2\u0e1d\u0e1e\t\6\2\2") + buf.write("\u0e1e\u0269\3\2\2\2\u0e1f\u0e20\t\f\2\2\u0e20\u0e21\t") + buf.write("\r\2\2\u0e21\u0e22\t\6\2\2\u0e22\u026b\3\2\2\2\u0e23\u0e24") + buf.write("\t\f\2\2\u0e24\u0e25\t\r\2\2\u0e25\u0e26\t\6\2\2\u0e26") + buf.write("\u0e27\t\n\2\2\u0e27\u0e28\t\21\2\2\u0e28\u0e29\t\n\2") + buf.write("\2\u0e29\u0e2a\t\5\2\2\u0e2a\u026d\3\2\2\2\u0e2b\u0e2c") + buf.write("\t\f\2\2\u0e2c\u0e2d\t\r\2\2\u0e2d\u0e2e\t\6\2\2\u0e2e") + buf.write("\u0e2f\t\n\2\2\u0e2f\u0e30\t\5\2\2\u0e30\u0e31\t\27\2") + buf.write("\2\u0e31\u0e32\t\2\2\2\u0e32\u0e33\t\b\2\2\u0e33\u026f") + buf.write("\3\2\2\2\u0e34\u0e35\t\b\2\2\u0e35\u0e36\t\n\2\2\u0e36") + buf.write("\u0e37\t\2\2\2\u0e37\u0e38\t\7\2\2\u0e38\u0e39\t\6\2\2") + buf.write("\u0e39\u0271\3\2\2\2\u0e3a\u0e3b\t\r\2\2\u0e3b\u0e3c\t") + buf.write("\2\2\2\u0e3c\u0e3d\t\6\2\2\u0e3d\u0e3e\t\f\2\2\u0e3e\u0e3f") + buf.write("\t\4\2\2\u0e3f\u0e40\t\r\2\2\u0e40\u0e41\t\2\2\2\u0e41") + buf.write("\u0e42\t\b\2\2\u0e42\u0273\3\2\2\2\u0e43\u0e44\t\r\2\2") + buf.write("\u0e44\u0e45\t\13\2\2\u0e45\u0e46\t\24\2\2\u0e46\u0e47") + buf.write("\t\2\2\2\u0e47\u0e48\t\5\2\2\u0e48\u0275\3\2\2\2\u0e49") + buf.write("\u0e4a\t\r\2\2\u0e4a\u0e4b\t\4\2\2\u0e4b\u0e4c\t\r\2\2") + buf.write("\u0e4c\u0e4d\t\n\2\2\u0e4d\u0277\3\2\2\2\u0e4e\u0e4f\t") + buf.write("\r\2\2\u0e4f\u0e50\t\t\2\2\u0e50\u0e51\t\b\2\2\u0e51\u0e52") + buf.write("\t\b\2\2\u0e52\u0e53\t\f\2\2\u0e53\u0e54\t\20\2\2\u0e54") + buf.write("\u0279\3\2\2\2\u0e55\u0e56\t\r\2\2\u0e56\u0e57\t\t\2\2") + buf.write("\u0e57\u0e58\t\17\2\2\u0e58\u0e59\t\n\2\2\u0e59\u0e5a") + buf.write("\t\5\2\2\u0e5a\u0e5b\t\f\2\2\u0e5b\u0e5c\t\13\2\2\u0e5c") + buf.write("\u027b\3\2\2\2\u0e5d\u0e5e\t\4\2\2\u0e5e\u0e5f\t\t\2\2") + buf.write("\u0e5f\u0e60\t\6\2\2\u0e60\u027d\3\2\2\2\u0e61\u0e62\t") + buf.write("\4\2\2\u0e62\u0e63\t\27\2\2\u0e63\u0e64\t\n\2\2\u0e64") + buf.write("\u0e65\t\5\2\2\u0e65\u0e66\t\b\2\2\u0e66\u0e67\t\2\2\2") + buf.write("\u0e67\u0e68\t\23\2\2\u0e68\u027f\3\2\2\2\u0e69\u0e6a") + buf.write("\t\26\2\2\u0e6a\u0e6b\t\4\2\2\u0e6b\u0e6c\t\7\2\2\u0e6c") + buf.write("\u0e6d\t\f\2\2\u0e6d\u0e6e\t\6\2\2\u0e6e\u0e6f\t\f\2\2") + buf.write("\u0e6f\u0e70\t\4\2\2\u0e70\u0e71\t\r\2\2\u0e71\u0281\3") + buf.write("\2\2\2\u0e72\u0e73\t\26\2\2\u0e73\u0e74\t\5\2\2\u0e74") + buf.write("\u0e75\t\n\2\2\u0e75\u0e76\t\13\2\2\u0e76\u0e77\t\f\2") + buf.write("\2\u0e77\u0e78\t\7\2\2\u0e78\u0e79\t\f\2\2\u0e79\u0e7a") + buf.write("\t\4\2\2\u0e7a\u0e7b\t\r\2\2\u0e7b\u0283\3\2\2\2\u0e7c") + buf.write("\u0e7d\t\5\2\2\u0e7d\u0e7e\t\n\2\2\u0e7e\u0e7f\t\2\2\2") + buf.write("\u0e7f\u0e80\t\b\2\2\u0e80\u0285\3\2\2\2\u0e81\u0e82\t") + buf.write("\5\2\2\u0e82\u0e83\t\4\2\2\u0e83\u0e84\t\22\2\2\u0e84") + buf.write("\u0287\3\2\2\2\u0e85\u0e86\t\7\2\2\u0e86\u0e87\t\n\2\2") + buf.write("\u0e87\u0e88\t\6\2\2\u0e88\u0e89\t\4\2\2\u0e89\u0e8a\t") + buf.write("\20\2\2\u0e8a\u0289\3\2\2\2\u0e8b\u0e8c\t\7\2\2\u0e8c") + buf.write("\u0e8d\t\17\2\2\u0e8d\u0e8e\t\2\2\2\u0e8e\u0e8f\t\b\2") + buf.write("\2\u0e8f\u0e90\t\b\2\2\u0e90\u0e91\t\f\2\2\u0e91\u0e92") + buf.write("\t\r\2\2\u0e92\u0e93\t\6\2\2\u0e93\u028b\3\2\2\2\u0e94") + buf.write("\u0e95\t\7\2\2\u0e95\u0e96\t\t\2\2\u0e96\u0e97\t\3\2\2") + buf.write("\u0e97\u0e98\t\7\2\2\u0e98\u0e99\t\6\2\2\u0e99\u0e9a\t") + buf.write("\5\2\2\u0e9a\u0e9b\t\f\2\2\u0e9b\u0e9c\t\r\2\2\u0e9c\u0e9d") + buf.write("\t\21\2\2\u0e9d\u028d\3\2\2\2\u0e9e\u0e9f\t\6\2\2\u0e9f") + buf.write("\u0ea0\t\f\2\2\u0ea0\u0ea1\t\17\2\2\u0ea1\u0ea2\t\n\2") + buf.write("\2\u0ea2\u028f\3\2\2\2\u0ea3\u0ea4\t\6\2\2\u0ea4\u0ea5") + buf.write("\t\f\2\2\u0ea5\u0ea6\t\17\2\2\u0ea6\u0ea7\t\n\2\2\u0ea7") + buf.write("\u0ea8\t\7\2\2\u0ea8\u0ea9\t\6\2\2\u0ea9\u0eaa\t\2\2\2") + buf.write("\u0eaa\u0eab\t\17\2\2\u0eab\u0eac\t\26\2\2\u0eac\u0291") + buf.write("\3\2\2\2\u0ead\u0eae\t\6\2\2\u0eae\u0eaf\t\5\2\2\u0eaf") + buf.write("\u0eb0\t\n\2\2\u0eb0\u0eb1\t\2\2\2\u0eb1\u0eb2\t\6\2\2") + buf.write("\u0eb2\u0293\3\2\2\2\u0eb3\u0eb4\t\6\2\2\u0eb4\u0eb5\t") + buf.write("\5\2\2\u0eb5\u0eb6\t\f\2\2\u0eb6\u0eb7\t\17\2\2\u0eb7") + buf.write("\u0295\3\2\2\2\u0eb8\u0eb9\t\27\2\2\u0eb9\u0eba\t\2\2") + buf.write("\2\u0eba\u0ebb\t\b\2\2\u0ebb\u0ebc\t\t\2\2\u0ebc\u0ebd") + buf.write("\t\n\2\2\u0ebd\u0ebe\t\7\2\2\u0ebe\u0297\3\2\2\2\u0ebf") + buf.write("\u0ec0\t\27\2\2\u0ec0\u0ec1\t\2\2\2\u0ec1\u0ec2\t\5\2") + buf.write("\2\u0ec2\u0ec3\t\13\2\2\u0ec3\u0ec4\t\24\2\2\u0ec4\u0ec5") + buf.write("\t\2\2\2\u0ec5\u0ec6\t\5\2\2\u0ec6\u0299\3\2\2\2\u0ec7") + buf.write("\u0ec8\t\30\2\2\u0ec8\u0ec9\t\17\2\2\u0ec9\u0eca\t\b\2") + buf.write("\2\u0eca\u0ecb\t\2\2\2\u0ecb\u0ecc\t\6\2\2\u0ecc\u0ecd") + buf.write("\t\6\2\2\u0ecd\u0ece\t\5\2\2\u0ece\u0ecf\t\f\2\2\u0ecf") + buf.write("\u0ed0\t\3\2\2\u0ed0\u0ed1\t\t\2\2\u0ed1\u0ed2\t\6\2\2") + buf.write("\u0ed2\u0ed3\t\n\2\2\u0ed3\u0ed4\t\7\2\2\u0ed4\u029b\3") + buf.write("\2\2\2\u0ed5\u0ed6\t\30\2\2\u0ed6\u0ed7\t\17\2\2\u0ed7") + buf.write("\u0ed8\t\b\2\2\u0ed8\u0ed9\t\13\2\2\u0ed9\u0eda\t\4\2") + buf.write("\2\u0eda\u0edb\t\r\2\2\u0edb\u0edc\t\13\2\2\u0edc\u0edd") + buf.write("\t\2\2\2\u0edd\u0ede\t\6\2\2\u0ede\u029d\3\2\2\2\u0edf") + buf.write("\u0ee0\t\30\2\2\u0ee0\u0ee1\t\17\2\2\u0ee1\u0ee2\t\b\2") + buf.write("\2\u0ee2\u0ee3\t\n\2\2\u0ee3\u0ee4\t\b\2\2\u0ee4\u0ee5") + buf.write("\t\n\2\2\u0ee5\u0ee6\t\17\2\2\u0ee6\u0ee7\t\n\2\2\u0ee7") + buf.write("\u0ee8\t\r\2\2\u0ee8\u0ee9\t\6\2\2\u0ee9\u029f\3\2\2\2") + buf.write("\u0eea\u0eeb\t\30\2\2\u0eeb\u0eec\t\17\2\2\u0eec\u0eed") + buf.write("\t\b\2\2\u0eed\u0eee\t\n\2\2\u0eee\u0eef\t\30\2\2\u0eef") + buf.write("\u0ef0\t\f\2\2\u0ef0\u0ef1\t\7\2\2\u0ef1\u0ef2\t\6\2\2") + buf.write("\u0ef2\u0ef3\t\7\2\2\u0ef3\u02a1\3\2\2\2\u0ef4\u0ef5\t") + buf.write("\30\2\2\u0ef5\u0ef6\t\17\2\2\u0ef6\u0ef7\t\b\2\2\u0ef7") + buf.write("\u0ef8\t\20\2\2\u0ef8\u0ef9\t\4\2\2\u0ef9\u0efa\t\5\2") + buf.write("\2\u0efa\u0efb\t\n\2\2\u0efb\u0efc\t\7\2\2\u0efc\u0efd") + buf.write("\t\6\2\2\u0efd\u02a3\3\2\2\2\u0efe\u0eff\t\30\2\2\u0eff") + buf.write("\u0f00\t\17\2\2\u0f00\u0f01\t\b\2\2\u0f01\u0f02\t\r\2") + buf.write("\2\u0f02\u0f03\t\2\2\2\u0f03\u0f04\t\17\2\2\u0f04\u0f05") + buf.write("\t\n\2\2\u0f05\u0f06\t\7\2\2\u0f06\u0f07\t\26\2\2\u0f07") + buf.write("\u0f08\t\2\2\2\u0f08\u0f09\t\13\2\2\u0f09\u0f0a\t\n\2") + buf.write("\2\u0f0a\u0f0b\t\7\2\2\u0f0b\u02a5\3\2\2\2\u0f0c\u0f0d") + buf.write("\t\30\2\2\u0f0d\u0f0e\t\17\2\2\u0f0e\u0f0f\t\b\2\2\u0f0f") + buf.write("\u0f10\t\26\2\2\u0f10\u0f11\t\2\2\2\u0f11\u0f12\t\5\2") + buf.write("\2\u0f12\u0f13\t\7\2\2\u0f13\u0f14\t\n\2\2\u0f14\u02a7") + buf.write("\3\2\2\2\u0f15\u0f16\t\30\2\2\u0f16\u0f17\t\17\2\2\u0f17") + buf.write("\u0f18\t\b\2\2\u0f18\u0f19\t\26\2\2\u0f19\u0f1a\t\f\2") + buf.write("\2\u0f1a\u02a9\3\2\2\2\u0f1b\u0f1c\t\30\2\2\u0f1c\u0f1d") + buf.write("\t\17\2\2\u0f1d\u0f1e\t\b\2\2\u0f1e\u0f1f\t\5\2\2\u0f1f") + buf.write("\u0f20\t\4\2\2\u0f20\u0f21\t\4\2\2\u0f21\u0f22\t\6\2\2") + buf.write("\u0f22\u02ab\3\2\2\2\u0f23\u0f24\t\30\2\2\u0f24\u0f25") + buf.write("\t\17\2\2\u0f25\u0f26\t\b\2\2\u0f26\u0f27\t\7\2\2\u0f27") + buf.write("\u0f28\t\n\2\2\u0f28\u0f29\t\5\2\2\u0f29\u0f2a\t\f\2\2") + buf.write("\u0f2a\u0f2b\t\2\2\2\u0f2b\u0f2c\t\b\2\2\u0f2c\u0f2d\t") + buf.write("\f\2\2\u0f2d\u0f2e\t\31\2\2\u0f2e\u0f2f\t\n\2\2\u0f2f") + buf.write("\u02ad\3\2\2\2\u0f30\u0f31\t\30\2\2\u0f31\u0f32\t\17\2") + buf.write("\2\u0f32\u0f33\t\b\2\2\u0f33\u0f34\t\6\2\2\u0f34\u0f35") + buf.write("\t\2\2\2\u0f35\u0f36\t\3\2\2\u0f36\u0f37\t\b\2\2\u0f37") + buf.write("\u0f38\t\n\2\2\u0f38\u02af\3\2\2\2\u0f39\u0f3a\t\2\2\2") + buf.write("\u0f3a\u0f3b\t\t\2\2\u0f3b\u0f3c\t\6\2\2\u0f3c\u0f3d\t") + buf.write("\24\2\2\u0f3d\u0f3e\t\4\2\2\u0f3e\u0f3f\t\5\2\2\u0f3f") + buf.write("\u0f40\t\f\2\2\u0f40\u0f41\t\31\2\2\u0f41\u0f42\t\2\2") + buf.write("\2\u0f42\u0f43\t\6\2\2\u0f43\u0f44\t\f\2\2\u0f44\u0f45") + buf.write("\t\4\2\2\u0f45\u0f46\t\r\2\2\u0f46\u02b1\3\2\2\2\u0f47") + buf.write("\u0f48\t\3\2\2\u0f48\u0f49\t\f\2\2\u0f49\u0f4a\t\r\2\2") + buf.write("\u0f4a\u0f4b\t\2\2\2\u0f4b\u0f4c\t\5\2\2\u0f4c\u0f4d\t") + buf.write("\23\2\2\u0f4d\u02b3\3\2\2\2\u0f4e\u0f4f\t\13\2\2\u0f4f") + buf.write("\u0f50\t\4\2\2\u0f50\u0f51\t\b\2\2\u0f51\u0f52\t\b\2\2") + buf.write("\u0f52\u0f53\t\2\2\2\u0f53\u0f54\t\6\2\2\u0f54\u0f55\t") + buf.write("\f\2\2\u0f55\u0f56\t\4\2\2\u0f56\u0f57\t\r\2\2\u0f57\u02b5") + buf.write("\3\2\2\2\u0f58\u0f59\t\13\2\2\u0f59\u0f5a\t\4\2\2\u0f5a") + buf.write("\u0f5b\t\r\2\2\u0f5b\u0f5c\t\13\2\2\u0f5c\u0f5d\t\t\2") + buf.write("\2\u0f5d\u0f5e\t\5\2\2\u0f5e\u0f5f\t\5\2\2\u0f5f\u0f60") + buf.write("\t\n\2\2\u0f60\u0f61\t\r\2\2\u0f61\u0f62\t\6\2\2\u0f62") + buf.write("\u0f63\t\b\2\2\u0f63\u0f64\t\23\2\2\u0f64\u02b7\3\2\2") + buf.write("\2\u0f65\u0f66\t\13\2\2\u0f66\u0f67\t\5\2\2\u0f67\u0f68") + buf.write("\t\4\2\2\u0f68\u0f69\t\7\2\2\u0f69\u0f6a\t\7\2\2\u0f6a") + buf.write("\u02b9\3\2\2\2\u0f6b\u0f6c\t\13\2\2\u0f6c\u0f6d\t\t\2") + buf.write("\2\u0f6d\u0f6e\t\5\2\2\u0f6e\u0f6f\t\5\2\2\u0f6f\u0f70") + buf.write("\t\n\2\2\u0f70\u0f71\t\r\2\2\u0f71\u0f72\t\6\2\2\u0f72") + buf.write("\u0f73\5\u0480\u0240\2\u0f73\u0f74\t\7\2\2\u0f74\u0f75") + buf.write("\t\13\2\2\u0f75\u0f76\t\24\2\2\u0f76\u0f77\t\n\2\2\u0f77") + buf.write("\u0f78\t\17\2\2\u0f78\u0f79\t\2\2\2\u0f79\u02bb\3\2\2") + buf.write("\2\u0f7a\u0f7b\t\20\2\2\u0f7b\u0f7c\t\5\2\2\u0f7c\u0f7d") + buf.write("\t\n\2\2\u0f7d\u0f7e\t\n\2\2\u0f7e\u0f7f\t\31\2\2\u0f7f") + buf.write("\u0f80\t\n\2\2\u0f80\u02bd\3\2\2\2\u0f81\u0f82\t\20\2") + buf.write("\2\u0f82\u0f83\t\t\2\2\u0f83\u0f84\t\b\2\2\u0f84\u0f85") + buf.write("\t\b\2\2\u0f85\u02bf\3\2\2\2\u0f86\u0f87\t\f\2\2\u0f87") + buf.write("\u0f88\t\b\2\2\u0f88\u0f89\t\f\2\2\u0f89\u0f8a\t\25\2") + buf.write("\2\u0f8a\u0f8b\t\n\2\2\u0f8b\u02c1\3\2\2\2\u0f8c\u0f8d") + buf.write("\t\f\2\2\u0f8d\u0f8e\t\r\2\2\u0f8e\u0f8f\t\r\2\2\u0f8f") + buf.write("\u0f90\t\n\2\2\u0f90\u0f91\t\5\2\2\u0f91\u02c3\3\2\2\2") + buf.write("\u0f92\u0f93\t\f\2\2\u0f93\u0f94\t\7\2\2\u0f94\u02c5\3") + buf.write("\2\2\2\u0f95\u0f96\t\f\2\2\u0f96\u0f97\t\7\2\2\u0f97\u0f98") + buf.write("\t\r\2\2\u0f98\u0f99\t\t\2\2\u0f99\u0f9a\t\b\2\2\u0f9a") + buf.write("\u0f9b\t\b\2\2\u0f9b\u02c7\3\2\2\2\u0f9c\u0f9d\t\32\2") + buf.write("\2\u0f9d\u0f9e\t\4\2\2\u0f9e\u0f9f\t\f\2\2\u0f9f\u0fa0") + buf.write("\t\r\2\2\u0fa0\u02c9\3\2\2\2\u0fa1\u0fa2\t\b\2\2\u0fa2") + buf.write("\u0fa3\t\n\2\2\u0fa3\u0fa4\t\20\2\2\u0fa4\u0fa5\t\6\2") + buf.write("\2\u0fa5\u02cb\3\2\2\2\u0fa6\u0fa7\t\b\2\2\u0fa7\u0fa8") + buf.write("\t\f\2\2\u0fa8\u0fa9\t\25\2\2\u0fa9\u0faa\t\n\2\2\u0faa") + buf.write("\u02cd\3\2\2\2\u0fab\u0fac\t\r\2\2\u0fac\u0fad\t\2\2\2") + buf.write("\u0fad\u0fae\t\6\2\2\u0fae\u0faf\t\t\2\2\u0faf\u0fb0\t") + buf.write("\5\2\2\u0fb0\u0fb1\t\2\2\2\u0fb1\u0fb2\t\b\2\2\u0fb2\u02cf") + buf.write("\3\2\2\2\u0fb3\u0fb4\t\r\2\2\u0fb4\u0fb5\t\4\2\2\u0fb5") + buf.write("\u0fb6\t\6\2\2\u0fb6\u0fb7\t\r\2\2\u0fb7\u0fb8\t\t\2\2") + buf.write("\u0fb8\u0fb9\t\b\2\2\u0fb9\u0fba\t\b\2\2\u0fba\u02d1\3") + buf.write("\2\2\2\u0fbb\u0fbc\t\4\2\2\u0fbc\u0fbd\t\t\2\2\u0fbd\u0fbe") + buf.write("\t\6\2\2\u0fbe\u0fbf\t\n\2\2\u0fbf\u0fc0\t\5\2\2\u0fc0") + buf.write("\u02d3\3\2\2\2\u0fc1\u0fc2\t\4\2\2\u0fc2\u0fc3\t\27\2") + buf.write("\2\u0fc3\u0fc4\t\n\2\2\u0fc4\u0fc5\t\5\2\2\u0fc5\u0fc6") + buf.write("\t\b\2\2\u0fc6\u0fc7\t\2\2\2\u0fc7\u0fc8\t\26\2\2\u0fc8") + buf.write("\u0fc9\t\7\2\2\u0fc9\u02d5\3\2\2\2\u0fca\u0fcb\t\5\2\2") + buf.write("\u0fcb\u0fcc\t\f\2\2\u0fcc\u0fcd\t\21\2\2\u0fcd\u0fce") + buf.write("\t\24\2\2\u0fce\u0fcf\t\6\2\2\u0fcf\u02d7\3\2\2\2\u0fd0") + buf.write("\u0fd1\t\7\2\2\u0fd1\u0fd2\t\f\2\2\u0fd2\u0fd3\t\17\2") + buf.write("\2\u0fd3\u0fd4\t\f\2\2\u0fd4\u0fd5\t\b\2\2\u0fd5\u0fd6") + buf.write("\t\2\2\2\u0fd6\u0fd7\t\5\2\2\u0fd7\u02d9\3\2\2\2\u0fd8") + buf.write("\u0fd9\t\6\2\2\u0fd9\u0fda\t\2\2\2\u0fda\u0fdb\t\3\2\2") + buf.write("\u0fdb\u0fdc\t\b\2\2\u0fdc\u0fdd\t\n\2\2\u0fdd\u0fde\t") + buf.write("\7\2\2\u0fde\u0fdf\t\2\2\2\u0fdf\u0fe0\t\17\2\2\u0fe0") + buf.write("\u0fe1\t\26\2\2\u0fe1\u0fe2\t\b\2\2\u0fe2\u0fe3\t\n\2") + buf.write("\2\u0fe3\u02db\3\2\2\2\u0fe4\u0fe5\t\27\2\2\u0fe5\u0fe6") + buf.write("\t\n\2\2\u0fe6\u0fe7\t\5\2\2\u0fe7\u0fe8\t\3\2\2\u0fe8") + buf.write("\u0fe9\t\4\2\2\u0fe9\u0fea\t\7\2\2\u0fea\u0feb\t\n\2\2") + buf.write("\u0feb\u02dd\3\2\2\2\u0fec\u0fed\t\2\2\2\u0fed\u0fee\t") + buf.write("\b\2\2\u0fee\u0fef\t\b\2\2\u0fef\u02df\3\2\2\2\u0ff0\u0ff1") + buf.write("\t\2\2\2\u0ff1\u0ff2\t\r\2\2\u0ff2\u0ff3\t\2\2\2\u0ff3") + buf.write("\u0ff4\t\b\2\2\u0ff4\u0ff5\t\23\2\2\u0ff5\u0ff6\t\7\2") + buf.write("\2\u0ff6\u0ff7\t\n\2\2\u0ff7\u02e1\3\2\2\2\u0ff8\u0ff9") + buf.write("\t\2\2\2\u0ff9\u0ffa\t\r\2\2\u0ffa\u0ffb\t\2\2\2\u0ffb") + buf.write("\u0ffc\t\b\2\2\u0ffc\u0ffd\t\23\2\2\u0ffd\u0ffe\t\31\2") + buf.write("\2\u0ffe\u0fff\t\n\2\2\u0fff\u02e3\3\2\2\2\u1000\u1001") + buf.write("\t\2\2\2\u1001\u1002\t\r\2\2\u1002\u1003\t\16\2\2\u1003") + buf.write("\u02e5\3\2\2\2\u1004\u1005\t\2\2\2\u1005\u1006\t\r\2\2") + buf.write("\u1006\u1007\t\23\2\2\u1007\u02e7\3\2\2\2\u1008\u1009") + buf.write("\t\2\2\2\u1009\u100a\t\5\2\2\u100a\u100b\t\5\2\2\u100b") + buf.write("\u100c\t\2\2\2\u100c\u100d\t\23\2\2\u100d\u02e9\3\2\2") + buf.write("\2\u100e\u100f\t\2\2\2\u100f\u1010\t\7\2\2\u1010\u02eb") + buf.write("\3\2\2\2\u1011\u1012\t\2\2\2\u1012\u1013\t\7\2\2\u1013") + buf.write("\u1014\t\13\2\2\u1014\u02ed\3\2\2\2\u1015\u1016\t\2\2") + buf.write("\2\u1016\u1017\t\7\2\2\u1017\u1018\t\23\2\2\u1018\u1019") + buf.write("\t\17\2\2\u1019\u101a\t\17\2\2\u101a\u101b\t\n\2\2\u101b") + buf.write("\u101c\t\6\2\2\u101c\u101d\t\5\2\2\u101d\u101e\t\f\2\2") + buf.write("\u101e\u101f\t\13\2\2\u101f\u02ef\3\2\2\2\u1020\u1021") + buf.write("\t\3\2\2\u1021\u1022\t\4\2\2\u1022\u1023\t\6\2\2\u1023") + buf.write("\u1024\t\24\2\2\u1024\u02f1\3\2\2\2\u1025\u1026\t\13\2") + buf.write("\2\u1026\u1027\t\2\2\2\u1027\u1028\t\7\2\2\u1028\u1029") + buf.write("\t\n\2\2\u1029\u02f3\3\2\2\2\u102a\u102b\t\13\2\2\u102b") + buf.write("\u102c\t\2\2\2\u102c\u102d\t\7\2\2\u102d\u102e\t\6\2\2") + buf.write("\u102e\u02f5\3\2\2\2\u102f\u1030\t\13\2\2\u1030\u1031") + buf.write("\t\24\2\2\u1031\u1032\t\n\2\2\u1032\u1033\t\13\2\2\u1033") + buf.write("\u1034\t\25\2\2\u1034\u02f7\3\2\2\2\u1035\u1036\t\13\2") + buf.write("\2\u1036\u1037\t\4\2\2\u1037\u1038\t\b\2\2\u1038\u1039") + buf.write("\t\b\2\2\u1039\u103a\t\2\2\2\u103a\u103b\t\6\2\2\u103b") + buf.write("\u103c\t\n\2\2\u103c\u02f9\3\2\2\2\u103d\u103e\t\13\2") + buf.write("\2\u103e\u103f\t\4\2\2\u103f\u1040\t\b\2\2\u1040\u1041") + buf.write("\t\t\2\2\u1041\u1042\t\17\2\2\u1042\u1043\t\r\2\2\u1043") + buf.write("\u02fb\3\2\2\2\u1044\u1045\t\13\2\2\u1045\u1046\t\4\2") + buf.write("\2\u1046\u1047\t\r\2\2\u1047\u1048\t\7\2\2\u1048\u1049") + buf.write("\t\6\2\2\u1049\u104a\t\5\2\2\u104a\u104b\t\2\2\2\u104b") + buf.write("\u104c\t\f\2\2\u104c\u104d\t\r\2\2\u104d\u104e\t\6\2\2") + buf.write("\u104e\u02fd\3\2\2\2\u104f\u1050\t\13\2\2\u1050\u1051") + buf.write("\t\5\2\2\u1051\u1052\t\n\2\2\u1052\u1053\t\2\2\2\u1053") + buf.write("\u1054\t\6\2\2\u1054\u1055\t\n\2\2\u1055\u02ff\3\2\2\2") + buf.write("\u1056\u1057\t\13\2\2\u1057\u1058\t\t\2\2\u1058\u1059") + buf.write("\t\5\2\2\u1059\u105a\t\5\2\2\u105a\u105b\t\n\2\2\u105b") + buf.write("\u105c\t\r\2\2\u105c\u105d\t\6\2\2\u105d\u105e\5\u0480") + buf.write("\u0240\2\u105e\u105f\t\13\2\2\u105f\u1060\t\2\2\2\u1060") + buf.write("\u1061\t\6\2\2\u1061\u1062\t\2\2\2\u1062\u1063\t\b\2\2") + buf.write("\u1063\u1064\t\4\2\2\u1064\u1065\t\21\2\2\u1065\u0301") + buf.write("\3\2\2\2\u1066\u1067\t\13\2\2\u1067\u1068\t\t\2\2\u1068") + buf.write("\u1069\t\5\2\2\u1069\u106a\t\5\2\2\u106a\u106b\t\n\2\2") + buf.write("\u106b\u106c\t\r\2\2\u106c\u106d\t\6\2\2\u106d\u106e\5") + buf.write("\u0480\u0240\2\u106e\u106f\t\16\2\2\u106f\u1070\t\2\2") + buf.write("\2\u1070\u1071\t\6\2\2\u1071\u1072\t\n\2\2\u1072\u0303") + buf.write("\3\2\2\2\u1073\u1074\t\13\2\2\u1074\u1075\t\t\2\2\u1075") + buf.write("\u1076\t\5\2\2\u1076\u1077\t\5\2\2\u1077\u1078\t\n\2\2") + buf.write("\u1078\u1079\t\r\2\2\u1079\u107a\t\6\2\2\u107a\u107b\5") + buf.write("\u0480\u0240\2\u107b\u107c\t\5\2\2\u107c\u107d\t\4\2\2") + buf.write("\u107d\u107e\t\b\2\2\u107e\u107f\t\n\2\2\u107f\u0305\3") + buf.write("\2\2\2\u1080\u1081\t\13\2\2\u1081\u1082\t\t\2\2\u1082") + buf.write("\u1083\t\5\2\2\u1083\u1084\t\5\2\2\u1084\u1085\t\n\2\2") + buf.write("\u1085\u1086\t\r\2\2\u1086\u1087\t\6\2\2\u1087\u1088\5") + buf.write("\u0480\u0240\2\u1088\u1089\t\6\2\2\u1089\u108a\t\f\2\2") + buf.write("\u108a\u108b\t\17\2\2\u108b\u108c\t\n\2\2\u108c\u0307") + buf.write("\3\2\2\2\u108d\u108e\t\13\2\2\u108e\u108f\t\t\2\2\u108f") + buf.write("\u1090\t\5\2\2\u1090\u1091\t\5\2\2\u1091\u1092\t\n\2\2") + buf.write("\u1092\u1093\t\r\2\2\u1093\u1094\t\6\2\2\u1094\u1095\5") + buf.write("\u0480\u0240\2\u1095\u1096\t\6\2\2\u1096\u1097\t\f\2\2") + buf.write("\u1097\u1098\t\17\2\2\u1098\u1099\t\n\2\2\u1099\u109a") + buf.write("\t\7\2\2\u109a\u109b\t\6\2\2\u109b\u109c\t\2\2\2\u109c") + buf.write("\u109d\t\17\2\2\u109d\u109e\t\26\2\2\u109e\u0309\3\2\2") + buf.write("\2\u109f\u10a0\t\13\2\2\u10a0\u10a1\t\t\2\2\u10a1\u10a2") + buf.write("\t\5\2\2\u10a2\u10a3\t\5\2\2\u10a3\u10a4\t\n\2\2\u10a4") + buf.write("\u10a5\t\r\2\2\u10a5\u10a6\t\6\2\2\u10a6\u10a7\5\u0480") + buf.write("\u0240\2\u10a7\u10a8\t\t\2\2\u10a8\u10a9\t\7\2\2\u10a9") + buf.write("\u10aa\t\n\2\2\u10aa\u10ab\t\5\2\2\u10ab\u030b\3\2\2\2") + buf.write("\u10ac\u10ad\t\16\2\2\u10ad\u10ae\t\n\2\2\u10ae\u10af") + buf.write("\t\20\2\2\u10af\u10b0\t\2\2\2\u10b0\u10b1\t\t\2\2\u10b1") + buf.write("\u10b2\t\b\2\2\u10b2\u10b3\t\6\2\2\u10b3\u030d\3\2\2\2") + buf.write("\u10b4\u10b5\t\16\2\2\u10b5\u10b6\t\n\2\2\u10b6\u10b7") + buf.write("\t\20\2\2\u10b7\u10b8\t\n\2\2\u10b8\u10b9\t\5\2\2\u10b9") + buf.write("\u10ba\t\5\2\2\u10ba\u10bb\t\2\2\2\u10bb\u10bc\t\3\2\2") + buf.write("\u10bc\u10bd\t\b\2\2\u10bd\u10be\t\n\2\2\u10be\u030f\3") + buf.write("\2\2\2\u10bf\u10c0\t\16\2\2\u10c0\u10c1\t\n\2\2\u10c1") + buf.write("\u10c2\t\7\2\2\u10c2\u10c3\t\13\2\2\u10c3\u0311\3\2\2") + buf.write("\2\u10c4\u10c5\t\16\2\2\u10c5\u10c6\t\f\2\2\u10c6\u10c7") + buf.write("\t\7\2\2\u10c7\u10c8\t\6\2\2\u10c8\u10c9\t\f\2\2\u10c9") + buf.write("\u10ca\t\r\2\2\u10ca\u10cb\t\13\2\2\u10cb\u10cc\t\6\2") + buf.write("\2\u10cc\u0313\3\2\2\2\u10cd\u10ce\t\16\2\2\u10ce\u10cf") + buf.write("\t\4\2\2\u10cf\u0315\3\2\2\2\u10d0\u10d1\t\n\2\2\u10d1") + buf.write("\u10d2\t\b\2\2\u10d2\u10d3\t\7\2\2\u10d3\u10d4\t\n\2\2") + buf.write("\u10d4\u0317\3\2\2\2\u10d5\u10d6\t\n\2\2\u10d6\u10d7\t") + buf.write("\r\2\2\u10d7\u10d8\t\16\2\2\u10d8\u0319\3\2\2\2\u10d9") + buf.write("\u10da\t\n\2\2\u10da\u10db\t\30\2\2\u10db\u10dc\t\13\2") + buf.write("\2\u10dc\u10dd\t\n\2\2\u10dd\u10de\t\26\2\2\u10de\u10df") + buf.write("\t\6\2\2\u10df\u031b\3\2\2\2\u10e0\u10e1\t\20\2\2\u10e1") + buf.write("\u10e2\t\2\2\2\u10e2\u10e3\t\b\2\2\u10e3\u10e4\t\7\2\2") + buf.write("\u10e4\u10e5\t\n\2\2\u10e5\u031d\3\2\2\2\u10e6\u10e7\t") + buf.write("\20\2\2\u10e7\u10e8\t\n\2\2\u10e8\u10e9\t\6\2\2\u10e9") + buf.write("\u10ea\t\13\2\2\u10ea\u10eb\t\24\2\2\u10eb\u031f\3\2\2") + buf.write("\2\u10ec\u10ed\t\20\2\2\u10ed\u10ee\t\4\2\2\u10ee\u10ef") + buf.write("\t\5\2\2\u10ef\u0321\3\2\2\2\u10f0\u10f1\t\20\2\2\u10f1") + buf.write("\u10f2\t\4\2\2\u10f2\u10f3\t\5\2\2\u10f3\u10f4\t\n\2\2") + buf.write("\u10f4\u10f5\t\f\2\2\u10f5\u10f6\t\21\2\2\u10f6\u10f7") + buf.write("\t\r\2\2\u10f7\u0323\3\2\2\2\u10f8\u10f9\t\20\2\2\u10f9") + buf.write("\u10fa\t\5\2\2\u10fa\u10fb\t\4\2\2\u10fb\u10fc\t\17\2") + buf.write("\2\u10fc\u0325\3\2\2\2\u10fd\u10fe\t\21\2\2\u10fe\u10ff") + buf.write("\t\5\2\2\u10ff\u1100\t\2\2\2\u1100\u1101\t\r\2\2\u1101") + buf.write("\u1102\t\6\2\2\u1102\u0327\3\2\2\2\u1103\u1104\t\21\2") + buf.write("\2\u1104\u1105\t\5\2\2\u1105\u1106\t\4\2\2\u1106\u1107") + buf.write("\t\t\2\2\u1107\u1108\t\26\2\2\u1108\u0329\3\2\2\2\u1109") + buf.write("\u110a\t\24\2\2\u110a\u110b\t\2\2\2\u110b\u110c\t\27\2") + buf.write("\2\u110c\u110d\t\f\2\2\u110d\u110e\t\r\2\2\u110e\u110f") + buf.write("\t\21\2\2\u110f\u032b\3\2\2\2\u1110\u1111\t\f\2\2\u1111") + buf.write("\u1112\t\r\2\2\u1112\u032d\3\2\2\2\u1113\u1114\t\f\2\2") + buf.write("\u1114\u1115\t\r\2\2\u1115\u1116\t\f\2\2\u1116\u1117\t") + buf.write("\6\2\2\u1117\u1118\t\f\2\2\u1118\u1119\t\2\2\2\u1119\u111a") + buf.write("\t\b\2\2\u111a\u111b\t\b\2\2\u111b\u111c\t\23\2\2\u111c") + buf.write("\u032f\3\2\2\2\u111d\u111e\t\f\2\2\u111e\u111f\t\r\2\2") + buf.write("\u111f\u1120\t\6\2\2\u1120\u1121\t\n\2\2\u1121\u1122\t") + buf.write("\5\2\2\u1122\u1123\t\7\2\2\u1123\u1124\t\n\2\2\u1124\u1125") + buf.write("\t\13\2\2\u1125\u1126\t\6\2\2\u1126\u0331\3\2\2\2\u1127") + buf.write("\u1128\t\f\2\2\u1128\u1129\t\r\2\2\u1129\u112a\t\6\2\2") + buf.write("\u112a\u112b\t\4\2\2\u112b\u0333\3\2\2\2\u112c\u112d\t") + buf.write("\b\2\2\u112d\u112e\t\2\2\2\u112e\u112f\t\6\2\2\u112f\u1130") + buf.write("\t\n\2\2\u1130\u1131\t\5\2\2\u1131\u1132\t\2\2\2\u1132") + buf.write("\u1133\t\b\2\2\u1133\u0335\3\2\2\2\u1134\u1135\t\b\2\2") + buf.write("\u1135\u1136\t\n\2\2\u1136\u1137\t\2\2\2\u1137\u1138\t") + buf.write("\16\2\2\u1138\u1139\t\f\2\2\u1139\u113a\t\r\2\2\u113a") + buf.write("\u113b\t\21\2\2\u113b\u0337\3\2\2\2\u113c\u113d\t\b\2") + buf.write("\2\u113d\u113e\t\f\2\2\u113e\u113f\t\17\2\2\u113f\u1140") + buf.write("\t\f\2\2\u1140\u1141\t\6\2\2\u1141\u0339\3\2\2\2\u1142") + buf.write("\u1143\t\b\2\2\u1143\u1144\t\4\2\2\u1144\u1145\t\13\2") + buf.write("\2\u1145\u1146\t\2\2\2\u1146\u1147\t\b\2\2\u1147\u1148") + buf.write("\t\6\2\2\u1148\u1149\t\f\2\2\u1149\u114a\t\17\2\2\u114a") + buf.write("\u114b\t\n\2\2\u114b\u033b\3\2\2\2\u114c\u114d\t\b\2\2") + buf.write("\u114d\u114e\t\4\2\2\u114e\u114f\t\13\2\2\u114f\u1150") + buf.write("\t\2\2\2\u1150\u1151\t\b\2\2\u1151\u1152\t\6\2\2\u1152") + buf.write("\u1153\t\f\2\2\u1153\u1154\t\17\2\2\u1154\u1155\t\n\2") + buf.write("\2\u1155\u1156\t\7\2\2\u1156\u1157\t\6\2\2\u1157\u1158") + buf.write("\t\2\2\2\u1158\u1159\t\17\2\2\u1159\u115a\t\26\2\2\u115a") + buf.write("\u033d\3\2\2\2\u115b\u115c\t\r\2\2\u115c\u115d\t\4\2\2") + buf.write("\u115d\u115e\t\6\2\2\u115e\u033f\3\2\2\2\u115f\u1160\t") + buf.write("\r\2\2\u1160\u1161\t\t\2\2\u1161\u1162\t\b\2\2\u1162\u1163") + buf.write("\t\b\2\2\u1163\u0341\3\2\2\2\u1164\u1165\t\4\2\2\u1165") + buf.write("\u1166\t\20\2\2\u1166\u1167\t\20\2\2\u1167\u1168\t\7\2") + buf.write("\2\u1168\u1169\t\n\2\2\u1169\u116a\t\6\2\2\u116a\u0343") + buf.write("\3\2\2\2\u116b\u116c\t\4\2\2\u116c\u116d\t\r\2\2\u116d") + buf.write("\u0345\3\2\2\2\u116e\u116f\t\4\2\2\u116f\u1170\t\r\2\2") + buf.write("\u1170\u1171\t\b\2\2\u1171\u1172\t\23\2\2\u1172\u0347") + buf.write("\3\2\2\2\u1173\u1174\t\4\2\2\u1174\u1175\t\5\2\2\u1175") + buf.write("\u0349\3\2\2\2\u1176\u1177\t\4\2\2\u1177\u1178\t\5\2\2") + buf.write("\u1178\u1179\t\16\2\2\u1179\u117a\t\n\2\2\u117a\u117b") + buf.write("\t\5\2\2\u117b\u034b\3\2\2\2\u117c\u117d\t\26\2\2\u117d") + buf.write("\u117e\t\b\2\2\u117e\u117f\t\2\2\2\u117f\u1180\t\13\2") + buf.write("\2\u1180\u1181\t\f\2\2\u1181\u1182\t\r\2\2\u1182\u1183") + buf.write("\t\21\2\2\u1183\u034d\3\2\2\2\u1184\u1185\t\26\2\2\u1185") + buf.write("\u1186\t\5\2\2\u1186\u1187\t\f\2\2\u1187\u1188\t\17\2") + buf.write("\2\u1188\u1189\t\2\2\2\u1189\u118a\t\5\2\2\u118a\u118b") + buf.write("\t\23\2\2\u118b\u034f\3\2\2\2\u118c\u118d\t\5\2\2\u118d") + buf.write("\u118e\t\n\2\2\u118e\u118f\t\20\2\2\u118f\u1190\t\n\2") + buf.write("\2\u1190\u1191\t\5\2\2\u1191\u1192\t\n\2\2\u1192\u1193") + buf.write("\t\r\2\2\u1193\u1194\t\13\2\2\u1194\u1195\t\n\2\2\u1195") + buf.write("\u1196\t\7\2\2\u1196\u0351\3\2\2\2\u1197\u1198\t\5\2\2") + buf.write("\u1198\u1199\t\n\2\2\u1199\u119a\t\6\2\2\u119a\u119b\t") + buf.write("\t\2\2\u119b\u119c\t\5\2\2\u119c\u119d\t\r\2\2\u119d\u119e") + buf.write("\t\f\2\2\u119e\u119f\t\r\2\2\u119f\u11a0\t\21\2\2\u11a0") + buf.write("\u0353\3\2\2\2\u11a1\u11a2\t\7\2\2\u11a2\u11a3\t\n\2\2") + buf.write("\u11a3\u11a4\t\b\2\2\u11a4\u11a5\t\n\2\2\u11a5\u11a6\t") + buf.write("\13\2\2\u11a6\u11a7\t\6\2\2\u11a7\u0355\3\2\2\2\u11a8") + buf.write("\u11a9\t\7\2\2\u11a9\u11aa\t\n\2\2\u11aa\u11ab\t\7\2\2") + buf.write("\u11ab\u11ac\t\7\2\2\u11ac\u11ad\t\f\2\2\u11ad\u11ae\t") + buf.write("\4\2\2\u11ae\u11af\t\r\2\2\u11af\u11b0\5\u0480\u0240\2") + buf.write("\u11b0\u11b1\t\t\2\2\u11b1\u11b2\t\7\2\2\u11b2\u11b3\t") + buf.write("\n\2\2\u11b3\u11b4\t\5\2\2\u11b4\u0357\3\2\2\2\u11b5\u11b6") + buf.write("\t\7\2\2\u11b6\u11b7\t\4\2\2\u11b7\u11b8\t\17\2\2\u11b8") + buf.write("\u11b9\t\n\2\2\u11b9\u0359\3\2\2\2\u11ba\u11bb\t\7\2\2") + buf.write("\u11bb\u11bc\t\23\2\2\u11bc\u11bd\t\17\2\2\u11bd\u11be") + buf.write("\t\17\2\2\u11be\u11bf\t\n\2\2\u11bf\u11c0\t\6\2\2\u11c0") + buf.write("\u11c1\t\5\2\2\u11c1\u11c2\t\f\2\2\u11c2\u11c3\t\13\2") + buf.write("\2\u11c3\u035b\3\2\2\2\u11c4\u11c5\t\6\2\2\u11c5\u11c6") + buf.write("\t\2\2\2\u11c6\u11c7\t\3\2\2\u11c7\u11c8\t\b\2\2\u11c8") + buf.write("\u11c9\t\n\2\2\u11c9\u035d\3\2\2\2\u11ca\u11cb\t\6\2\2") + buf.write("\u11cb\u11cc\t\24\2\2\u11cc\u11cd\t\n\2\2\u11cd\u11ce") + buf.write("\t\r\2\2\u11ce\u035f\3\2\2\2\u11cf\u11d0\t\6\2\2\u11d0") + buf.write("\u11d1\t\4\2\2\u11d1\u0361\3\2\2\2\u11d2\u11d3\t\6\2\2") + buf.write("\u11d3\u11d4\t\5\2\2\u11d4\u11d5\t\2\2\2\u11d5\u11d6\t") + buf.write("\f\2\2\u11d6\u11d7\t\b\2\2\u11d7\u11d8\t\f\2\2\u11d8\u11d9") + buf.write("\t\r\2\2\u11d9\u11da\t\21\2\2\u11da\u0363\3\2\2\2\u11db") + buf.write("\u11dc\t\6\2\2\u11dc\u11dd\t\5\2\2\u11dd\u11de\t\t\2\2") + buf.write("\u11de\u11df\t\n\2\2\u11df\u0365\3\2\2\2\u11e0\u11e1\t") + buf.write("\t\2\2\u11e1\u11e2\t\r\2\2\u11e2\u11e3\t\f\2\2\u11e3\u11e4") + buf.write("\t\4\2\2\u11e4\u11e5\t\r\2\2\u11e5\u0367\3\2\2\2\u11e6") + buf.write("\u11e7\t\t\2\2\u11e7\u11e8\t\r\2\2\u11e8\u11e9\t\f\2\2") + buf.write("\u11e9\u11ea\t\33\2\2\u11ea\u11eb\t\t\2\2\u11eb\u11ec") + buf.write("\t\n\2\2\u11ec\u0369\3\2\2\2\u11ed\u11ee\t\t\2\2\u11ee") + buf.write("\u11ef\t\7\2\2\u11ef\u11f0\t\n\2\2\u11f0\u11f1\t\5\2\2") + buf.write("\u11f1\u036b\3\2\2\2\u11f2\u11f3\t\t\2\2\u11f3\u11f4\t") + buf.write("\7\2\2\u11f4\u11f5\t\f\2\2\u11f5\u11f6\t\r\2\2\u11f6\u11f7") + buf.write("\t\21\2\2\u11f7\u036d\3\2\2\2\u11f8\u11f9\t\27\2\2\u11f9") + buf.write("\u11fa\t\2\2\2\u11fa\u11fb\t\5\2\2\u11fb\u11fc\t\f\2\2") + buf.write("\u11fc\u11fd\t\2\2\2\u11fd\u11fe\t\16\2\2\u11fe\u11ff") + buf.write("\t\f\2\2\u11ff\u1200\t\13\2\2\u1200\u036f\3\2\2\2\u1201") + buf.write("\u1202\t\22\2\2\u1202\u1203\t\24\2\2\u1203\u1204\t\n\2") + buf.write("\2\u1204\u1205\t\r\2\2\u1205\u0371\3\2\2\2\u1206\u1207") + buf.write("\t\22\2\2\u1207\u1208\t\24\2\2\u1208\u1209\t\n\2\2\u1209") + buf.write("\u120a\t\5\2\2\u120a\u120b\t\n\2\2\u120b\u0373\3\2\2\2") + buf.write("\u120c\u120d\t\22\2\2\u120d\u120e\t\f\2\2\u120e\u120f") + buf.write("\t\r\2\2\u120f\u1210\t\16\2\2\u1210\u1211\t\4\2\2\u1211") + buf.write("\u1212\t\22\2\2\u1212\u0375\3\2\2\2\u1213\u1214\t\22\2") + buf.write("\2\u1214\u1215\t\f\2\2\u1215\u1216\t\6\2\2\u1216\u1217") + buf.write("\t\24\2\2\u1217\u0377\3\2\2\2\u1218\u1219\t\2\2\2\u1219") + buf.write("\u121a\t\b\2\2\u121a\u121b\t\f\2\2\u121b\u121c\t\21\2") + buf.write("\2\u121c\u121d\t\r\2\2\u121d\u121e\t\17\2\2\u121e\u121f") + buf.write("\t\n\2\2\u121f\u1220\t\r\2\2\u1220\u1221\t\6\2\2\u1221") + buf.write("\u0379\3\2\2\2\u1222\u1223\t\3\2\2\u1223\u1224\t\2\2\2") + buf.write("\u1224\u1225\t\7\2\2\u1225\u1226\t\n\2\2\u1226\u1227\t") + buf.write("\6\2\2\u1227\u1228\t\23\2\2\u1228\u1229\t\26\2\2\u1229") + buf.write("\u122a\t\n\2\2\u122a\u037b\3\2\2\2\u122b\u122c\t\3\2\2") + buf.write("\u122c\u122d\t\t\2\2\u122d\u122e\t\20\2\2\u122e\u122f") + buf.write("\t\20\2\2\u122f\u1230\t\n\2\2\u1230\u1231\t\5\2\2\u1231") + buf.write("\u1232\t\7\2\2\u1232\u037d\3\2\2\2\u1233\u1234\t\3\2\2") + buf.write("\u1234\u1235\t\23\2\2\u1235\u1236\t\26\2\2\u1236\u1237") + buf.write("\t\2\2\2\u1237\u1238\t\7\2\2\u1238\u1239\t\7\2\2\u1239") + buf.write("\u123a\t\5\2\2\u123a\u123b\t\b\2\2\u123b\u123c\t\7\2\2") + buf.write("\u123c\u037f\3\2\2\2\u123d\u123e\t\13\2\2\u123e\u123f") + buf.write("\t\2\2\2\u123f\u1240\t\r\2\2\u1240\u1241\t\4\2\2\u1241") + buf.write("\u1242\t\r\2\2\u1242\u1243\t\f\2\2\u1243\u1244\t\13\2") + buf.write("\2\u1244\u1245\t\2\2\2\u1245\u1246\t\b\2\2\u1246\u0381") + buf.write("\3\2\2\2\u1247\u1248\t\13\2\2\u1248\u1249\t\2\2\2\u1249") + buf.write("\u124a\t\6\2\2\u124a\u124b\t\n\2\2\u124b\u124c\t\21\2") + buf.write("\2\u124c\u124d\t\4\2\2\u124d\u124e\t\5\2\2\u124e\u124f") + buf.write("\t\23\2\2\u124f\u0383\3\2\2\2\u1250\u1251\t\13\2\2\u1251") + buf.write("\u1252\t\4\2\2\u1252\u1253\t\b\2\2\u1253\u1254\t\b\2\2") + buf.write("\u1254\u1255\t\2\2\2\u1255\u1256\t\6\2\2\u1256\u1257\t") + buf.write("\2\2\2\u1257\u1258\t\3\2\2\u1258\u1259\t\b\2\2\u1259\u125a") + buf.write("\t\n\2\2\u125a\u0385\3\2\2\2\u125b\u125c\t\13\2\2\u125c") + buf.write("\u125d\t\4\2\2\u125d\u125e\t\17\2\2\u125e\u125f\t\3\2") + buf.write("\2\u125f\u1260\t\f\2\2\u1260\u1261\t\r\2\2\u1261\u1262") + buf.write("\t\n\2\2\u1262\u1263\t\20\2\2\u1263\u1264\t\t\2\2\u1264") + buf.write("\u1265\t\r\2\2\u1265\u1266\t\13\2\2\u1266\u0387\3\2\2") + buf.write("\2\u1267\u1268\t\13\2\2\u1268\u1269\t\4\2\2\u1269\u126a") + buf.write("\t\17\2\2\u126a\u126b\t\17\2\2\u126b\u126c\t\t\2\2\u126c") + buf.write("\u126d\t\6\2\2\u126d\u126e\t\2\2\2\u126e\u126f\t\6\2\2") + buf.write("\u126f\u1270\t\4\2\2\u1270\u1271\t\5\2\2\u1271\u0389\3") + buf.write("\2\2\2\u1272\u1273\t\13\2\2\u1273\u1274\t\4\2\2\u1274") + buf.write("\u1275\t\r\2\2\u1275\u1276\t\r\2\2\u1276\u1277\t\n\2\2") + buf.write("\u1277\u1278\t\13\2\2\u1278\u1279\t\6\2\2\u1279\u038b") + buf.write("\3\2\2\2\u127a\u127b\t\13\2\2\u127b\u127c\t\4\2\2\u127c") + buf.write("\u127d\t\7\2\2\u127d\u127e\t\6\2\2\u127e\u127f\t\7\2\2") + buf.write("\u127f\u038d\3\2\2\2\u1280\u1281\t\13\2\2\u1281\u1282") + buf.write("\t\5\2\2\u1282\u1283\t\n\2\2\u1283\u1284\t\2\2\2\u1284") + buf.write("\u1285\t\6\2\2\u1285\u1286\t\n\2\2\u1286\u1287\t\16\2") + buf.write("\2\u1287\u1288\t\3\2\2\u1288\u038f\3\2\2\2\u1289\u128a") + buf.write("\t\13\2\2\u128a\u128b\t\5\2\2\u128b\u128c\t\n\2\2\u128c") + buf.write("\u128d\t\2\2\2\u128d\u128e\t\6\2\2\u128e\u128f\t\n\2\2") + buf.write("\u128f\u1290\t\5\2\2\u1290\u1291\t\4\2\2\u1291\u1292\t") + buf.write("\b\2\2\u1292\u1293\t\n\2\2\u1293\u0391\3\2\2\2\u1294\u1295") + buf.write("\t\16\2\2\u1295\u1296\t\n\2\2\u1296\u1297\t\7\2\2\u1297") + buf.write("\u1298\t\n\2\2\u1298\u1299\t\5\2\2\u1299\u129a\t\f\2\2") + buf.write("\u129a\u129b\t\2\2\2\u129b\u129c\t\b\2\2\u129c\u129d\t") + buf.write("\20\2\2\u129d\u129e\t\t\2\2\u129e\u129f\t\r\2\2\u129f") + buf.write("\u12a0\t\13\2\2\u12a0\u0393\3\2\2\2\u12a1\u12a2\t\16\2") + buf.write("\2\u12a2\u12a3\t\n\2\2\u12a3\u12a4\t\6\2\2\u12a4\u12a5") + buf.write("\t\n\2\2\u12a5\u12a6\t\5\2\2\u12a6\u12a7\t\17\2\2\u12a7") + buf.write("\u12a8\t\f\2\2\u12a8\u12a9\t\r\2\2\u12a9\u12aa\t\f\2\2") + buf.write("\u12aa\u12ab\t\7\2\2\u12ab\u12ac\t\6\2\2\u12ac\u12ad\t") + buf.write("\f\2\2\u12ad\u12ae\t\13\2\2\u12ae\u0395\3\2\2\2\u12af") + buf.write("\u12b0\5\u0086C\2\u12b0\u12b1\5\u0480\u0240\2\u12b1\u12b2") + buf.write("\t\26\2\2\u12b2\u12b3\t\2\2\2\u12b3\u12b4\t\21\2\2\u12b4") + buf.write("\u12b5\t\n\2\2\u12b5\u12b6\5\u0480\u0240\2\u12b6\u12b7") + buf.write("\t\7\2\2\u12b7\u12b8\t\25\2\2\u12b8\u12b9\t\f\2\2\u12b9") + buf.write("\u12ba\t\26\2\2\u12ba\u12bb\t\26\2\2\u12bb\u12bc\t\f\2") + buf.write("\2\u12bc\u12bd\t\r\2\2\u12bd\u12be\t\21\2\2\u12be\u0397") + buf.write("\3\2\2\2\u12bf\u12c0\t\n\2\2\u12c0\u12c1\t\b\2\2\u12c1") + buf.write("\u12c2\t\n\2\2\u12c2\u12c3\t\17\2\2\u12c3\u12c4\t\n\2") + buf.write("\2\u12c4\u12c5\t\r\2\2\u12c5\u12c6\t\6\2\2\u12c6\u0399") + buf.write("\3\2\2\2\u12c7\u12c8\t\n\2\2\u12c8\u12c9\t\30\2\2\u12c9") + buf.write("\u12ca\t\6\2\2\u12ca\u12cb\t\n\2\2\u12cb\u12cc\t\r\2\2") + buf.write("\u12cc\u12cd\t\16\2\2\u12cd\u12ce\t\n\2\2\u12ce\u12cf") + buf.write("\t\16\2\2\u12cf\u039b\3\2\2\2\u12d0\u12d1\t\20\2\2\u12d1") + buf.write("\u12d2\t\f\2\2\u12d2\u12d3\t\r\2\2\u12d3\u12d4\t\2\2\2") + buf.write("\u12d4\u12d5\t\b\2\2\u12d5\u12d6\t\20\2\2\u12d6\u12d7") + buf.write("\t\t\2\2\u12d7\u12d8\t\r\2\2\u12d8\u12d9\t\13\2\2\u12d9") + buf.write("\u039d\3\2\2\2\u12da\u12db\5\u039c\u01ce\2\u12db\u12dc") + buf.write("\5\u0480\u0240\2\u12dc\u12dd\t\n\2\2\u12dd\u12de\t\30") + buf.write("\2\2\u12de\u12df\t\6\2\2\u12df\u12e0\t\5\2\2\u12e0\u12e1") + buf.write("\t\2\2\2\u12e1\u039f\3\2\2\2\u12e2\u12e3\5\u039c\u01ce") + buf.write("\2\u12e3\u12e4\5\u0480\u0240\2\u12e4\u12e5\t\17\2\2\u12e5") + buf.write("\u12e6\t\4\2\2\u12e6\u12e7\t\16\2\2\u12e7\u12e8\t\f\2") + buf.write("\2\u12e8\u12e9\t\20\2\2\u12e9\u12ea\t\23\2\2\u12ea\u03a1") + buf.write("\3\2\2\2\u12eb\u12ec\t\20\2\2\u12ec\u12ed\t\4\2\2\u12ed") + buf.write("\u12ee\t\5\2\2\u12ee\u12ef\t\13\2\2\u12ef\u12f0\t\n\2") + buf.write("\2\u12f0\u12f1\5\u0480\u0240\2\u12f1\u12f2\t\r\2\2\u12f2") + buf.write("\u12f3\t\4\2\2\u12f3\u12f4\t\6\2\2\u12f4\u12f5\5\u0480") + buf.write("\u0240\2\u12f5\u12f6\t\r\2\2\u12f6\u12f7\t\t\2\2\u12f7") + buf.write("\u12f8\t\b\2\2\u12f8\u12f9\t\b\2\2\u12f9\u03a3\3\2\2\2") + buf.write("\u12fa\u12fb\t\20\2\2\u12fb\u12fc\t\4\2\2\u12fc\u12fd") + buf.write("\t\5\2\2\u12fd\u12fe\t\13\2\2\u12fe\u12ff\t\n\2\2\u12ff") + buf.write("\u1300\5\u0480\u0240\2\u1300\u1301\t\r\2\2\u1301\u1302") + buf.write("\t\t\2\2\u1302\u1303\t\b\2\2\u1303\u1304\t\b\2\2\u1304") + buf.write("\u03a5\3\2\2\2\u1305\u1306\t\20\2\2\u1306\u1307\t\4\2") + buf.write("\2\u1307\u1308\t\5\2\2\u1308\u1309\t\13\2\2\u1309\u130a") + buf.write("\t\n\2\2\u130a\u130b\5\u0480\u0240\2\u130b\u130c\t\33") + buf.write("\2\2\u130c\u130d\t\t\2\2\u130d\u130e\t\4\2\2\u130e\u130f") + buf.write("\t\6\2\2\u130f\u1310\t\n\2\2\u1310\u03a7\3\2\2\2\u1311") + buf.write("\u1312\t\20\2\2\u1312\u1313\t\4\2\2\u1313\u1314\t\5\2") + buf.write("\2\u1314\u1315\t\17\2\2\u1315\u1316\t\2\2\2\u1316\u1317") + buf.write("\t\6\2\2\u1317\u03a9\3\2\2\2\u1318\u1319\t\21\2\2\u1319") + buf.write("\u131a\t\n\2\2\u131a\u131b\t\6\2\2\u131b\u131c\t\6\2\2") + buf.write("\u131c\u131d\t\4\2\2\u131d\u131e\t\25\2\2\u131e\u131f") + buf.write("\t\n\2\2\u131f\u1320\t\r\2\2\u1320\u03ab\3\2\2\2\u1321") + buf.write("\u1322\t\24\2\2\u1322\u1323\t\2\2\2\u1323\u1324\t\7\2") + buf.write("\2\u1324\u1325\t\24\2\2\u1325\u03ad\3\2\2\2\u1326\u1327") + buf.write("\t\24\2\2\u1327\u1328\t\2\2\2\u1328\u1329\t\7\2\2\u1329") + buf.write("\u132a\t\24\2\2\u132a\u132b\t\n\2\2\u132b\u132c\t\7\2") + buf.write("\2\u132c\u03af\3\2\2\2\u132d\u132e\t\24\2\2\u132e\u132f") + buf.write("\t\n\2\2\u132f\u1330\t\2\2\2\u1330\u1331\t\16\2\2\u1331") + buf.write("\u1332\t\b\2\2\u1332\u1333\t\f\2\2\u1333\u1334\t\r\2\2") + buf.write("\u1334\u1335\t\n\2\2\u1335\u03b1\3\2\2\2\u1336\u1337\t") + buf.write("\24\2\2\u1337\u1338\t\23\2\2\u1338\u1339\t\26\2\2\u1339") + buf.write("\u133a\t\4\2\2\u133a\u133b\t\6\2\2\u133b\u133c\t\24\2") + buf.write("\2\u133c\u133d\t\n\2\2\u133d\u133e\t\6\2\2\u133e\u133f") + buf.write("\t\f\2\2\u133f\u1340\t\13\2\2\u1340\u1341\t\2\2\2\u1341") + buf.write("\u1342\t\b\2\2\u1342\u03b3\3\2\2\2\u1343\u1344\t\f\2\2") + buf.write("\u1344\u1345\t\r\2\2\u1345\u1346\t\16\2\2\u1346\u1347") + buf.write("\t\n\2\2\u1347\u1348\t\30\2\2\u1348\u1349\5\u0480\u0240") + buf.write("\2\u1349\u134a\t\13\2\2\u134a\u134b\t\b\2\2\u134b\u134c") + buf.write("\t\n\2\2\u134c\u134d\t\2\2\2\u134d\u134e\t\r\2\2\u134e") + buf.write("\u134f\t\t\2\2\u134f\u1350\t\26\2\2\u1350\u03b5\3\2\2") + buf.write("\2\u1351\u1352\t\f\2\2\u1352\u1353\t\r\2\2\u1353\u1354") + buf.write("\t\f\2\2\u1354\u1355\t\6\2\2\u1355\u03b7\3\2\2\2\u1356") + buf.write("\u1357\t\f\2\2\u1357\u1358\t\r\2\2\u1358\u1359\t\f\2\2") + buf.write("\u1359\u135a\t\6\2\2\u135a\u135b\t\13\2\2\u135b\u135c") + buf.write("\t\4\2\2\u135c\u135d\t\r\2\2\u135d\u135e\t\16\2\2\u135e") + buf.write("\u03b9\3\2\2\2\u135f\u1360\t\f\2\2\u1360\u1361\t\r\2\2") + buf.write("\u1361\u1362\t\6\2\2\u1362\u1363\t\n\2\2\u1363\u1364\t") + buf.write("\5\2\2\u1364\u1365\t\r\2\2\u1365\u1366\t\2\2\2\u1366\u1367") + buf.write("\t\b\2\2\u1367\u1368\t\b\2\2\u1368\u1369\t\n\2\2\u1369") + buf.write("\u136a\t\r\2\2\u136a\u136b\t\21\2\2\u136b\u136c\t\6\2") + buf.write("\2\u136c\u136d\t\24\2\2\u136d\u03bb\3\2\2\2\u136e\u136f") + buf.write("\t\32\2\2\u136f\u1370\t\7\2\2\u1370\u1371\t\4\2\2\u1371") + buf.write("\u1372\t\r\2\2\u1372\u03bd\3\2\2\2\u1373\u1374\t\b\2\2") + buf.write("\u1374\u1375\t\13\2\2\u1375\u1376\5\u0480\u0240\2\u1376") + buf.write("\u1377\t\13\2\2\u1377\u1378\t\4\2\2\u1378\u1379\t\b\2") + buf.write("\2\u1379\u137a\t\b\2\2\u137a\u137b\t\2\2\2\u137b\u137c") + buf.write("\t\6\2\2\u137c\u137d\t\n\2\2\u137d\u03bf\3\2\2\2\u137e") + buf.write("\u137f\t\b\2\2\u137f\u1380\t\13\2\2\u1380\u1381\5\u0480") + buf.write("\u0240\2\u1381\u1382\t\13\2\2\u1382\u1383\t\6\2\2\u1383") + buf.write("\u1384\t\23\2\2\u1384\u1385\t\26\2\2\u1385\u1386\t\n\2") + buf.write("\2\u1386\u03c1\3\2\2\2\u1387\u1388\t\b\2\2\u1388\u1389") + buf.write("\t\n\2\2\u1389\u138a\t\20\2\2\u138a\u138b\t\6\2\2\u138b") + buf.write("\u138c\t\2\2\2\u138c\u138d\t\5\2\2\u138d\u138e\t\21\2") + buf.write("\2\u138e\u03c3\3\2\2\2\u138f\u1390\t\b\2\2\u1390\u1391") + buf.write("\t\n\2\2\u1391\u1392\t\30\2\2\u1392\u1393\t\f\2\2\u1393") + buf.write("\u1394\t\31\2\2\u1394\u1395\t\n\2\2\u1395\u03c5\3\2\2") + buf.write("\2\u1396\u1397\t\b\2\2\u1397\u1398\t\n\2\2\u1398\u1399") + buf.write("\t\30\2\2\u1399\u139a\t\6\2\2\u139a\u139b\t\23\2\2\u139b") + buf.write("\u139c\t\26\2\2\u139c\u139d\t\n\2\2\u139d\u139e\t\7\2") + buf.write("\2\u139e\u03c7\3\2\2\2\u139f\u13a0\t\b\2\2\u13a0\u13a1") + buf.write("\t\f\2\2\u13a1\u13a2\t\7\2\2\u13a2\u13a3\t\6\2\2\u13a3") + buf.write("\u03c9\3\2\2\2\u13a4\u13a5\t\b\2\2\u13a5\u13a6\t\4\2\2") + buf.write("\u13a6\u13a7\t\13\2\2\u13a7\u13a8\t\2\2\2\u13a8\u13a9") + buf.write("\t\b\2\2\u13a9\u13aa\t\n\2\2\u13aa\u03cb\3\2\2\2\u13ab") + buf.write("\u13ac\t\b\2\2\u13ac\u13ad\t\4\2\2\u13ad\u13ae\t\21\2") + buf.write("\2\u13ae\u13af\t\f\2\2\u13af\u13b0\t\r\2\2\u13b0\u03cd") + buf.write("\3\2\2\2\u13b1\u13b2\t\17\2\2\u13b2\u13b3\t\2\2\2\u13b3") + buf.write("\u13b4\t\f\2\2\u13b4\u13b5\t\r\2\2\u13b5\u03cf\3\2\2\2") + buf.write("\u13b6\u13b7\t\17\2\2\u13b7\u13b8\t\n\2\2\u13b8\u13b9") + buf.write("\t\5\2\2\u13b9\u13ba\t\21\2\2\u13ba\u13bb\t\n\2\2\u13bb") + buf.write("\u13bc\t\7\2\2\u13bc\u03d1\3\2\2\2\u13bd\u13be\t\17\2") + buf.write("\2\u13be\u13bf\t\20\2\2\u13bf\u13c0\t\f\2\2\u13c0\u13c1") + buf.write("\t\r\2\2\u13c1\u13c2\t\2\2\2\u13c2\u13c3\t\b\2\2\u13c3") + buf.write("\u13c4\t\20\2\2\u13c4\u13c5\t\t\2\2\u13c5\u13c6\t\r\2") + buf.write("\2\u13c6\u13c7\t\13\2\2\u13c7\u03d3\3\2\2\2\u13c8\u13c9") + buf.write("\5\u03d2\u01e9\2\u13c9\u13ca\5\u0480\u0240\2\u13ca\u13cb") + buf.write("\t\n\2\2\u13cb\u13cc\t\30\2\2\u13cc\u13cd\t\6\2\2\u13cd") + buf.write("\u13ce\t\5\2\2\u13ce\u13cf\t\2\2\2\u13cf\u03d5\3\2\2\2") + buf.write("\u13d0\u13d1\5\u03d2\u01e9\2\u13d1\u13d2\5\u0480\u0240") + buf.write("\2\u13d2\u13d3\t\17\2\2\u13d3\u13d4\t\4\2\2\u13d4\u13d5") + buf.write("\t\16\2\2\u13d5\u13d6\t\f\2\2\u13d6\u13d7\t\20\2\2\u13d7") + buf.write("\u13d8\t\23\2\2\u13d8\u03d7\3\2\2\2\u13d9\u13da\t\17\2") + buf.write("\2\u13da\u13db\t\f\2\2\u13db\u13dc\t\r\2\2\u13dc\u13dd") + buf.write("\t\f\2\2\u13dd\u13de\t\6\2\2\u13de\u13df\t\13\2\2\u13df") + buf.write("\u13e0\t\4\2\2\u13e0\u13e1\t\r\2\2\u13e1\u13e2\t\16\2") + buf.write("\2\u13e2\u03d9\3\2\2\2\u13e3\u13e4\t\17\2\2\u13e4\u13e5") + buf.write("\t\f\2\2\u13e5\u13e6\t\r\2\2\u13e6\u13e7\t\27\2\2\u13e7") + buf.write("\u13e8\t\20\2\2\u13e8\u13e9\t\t\2\2\u13e9\u13ea\t\r\2") + buf.write("\2\u13ea\u13eb\t\13\2\2\u13eb\u03db\3\2\2\2\u13ec\u13ed") + buf.write("\t\17\2\2\u13ed\u13ee\t\4\2\2\u13ee\u13ef\t\16\2\2\u13ef") + buf.write("\u13f0\t\t\2\2\u13f0\u13f1\t\b\2\2\u13f1\u13f2\t\t\2\2") + buf.write("\u13f2\u13f3\t\7\2\2\u13f3\u03dd\3\2\2\2\u13f4\u13f5\t") + buf.write("\17\2\2\u13f5\u13f6\t\7\2\2\u13f6\u13f7\t\20\2\2\u13f7") + buf.write("\u13f8\t\t\2\2\u13f8\u13f9\t\r\2\2\u13f9\u13fa\t\13\2") + buf.write("\2\u13fa\u03df\3\2\2\2\u13fb\u13fc\t\17\2\2\u13fc\u13fd") + buf.write("\t\7\2\2\u13fd\u13fe\t\7\2\2\u13fe\u13ff\t\26\2\2\u13ff") + buf.write("\u1400\t\2\2\2\u1400\u1401\t\13\2\2\u1401\u1402\t\n\2") + buf.write("\2\u1402\u03e1\3\2\2\2\u1403\u1404\t\17\2\2\u1404\u1405") + buf.write("\t\7\2\2\u1405\u1406\t\6\2\2\u1406\u1407\t\23\2\2\u1407") + buf.write("\u1408\t\26\2\2\u1408\u1409\t\n\2\2\u1409\u03e3\3\2\2") + buf.write("\2\u140a\u140b\t\r\2\2\u140b\u140c\t\n\2\2\u140c\u140d") + buf.write("\t\21\2\2\u140d\u140e\t\2\2\2\u140e\u140f\t\6\2\2\u140f") + buf.write("\u1410\t\4\2\2\u1410\u1411\t\5\2\2\u1411\u03e5\3\2\2\2") + buf.write("\u1412\u1413\t\r\2\2\u1413\u1414\t\4\2\2\u1414\u1415\t") + buf.write("\3\2\2\u1415\u1416\t\23\2\2\u1416\u1417\t\26\2\2\u1417") + buf.write("\u1418\t\2\2\2\u1418\u1419\t\7\2\2\u1419\u141a\t\7\2\2") + buf.write("\u141a\u141b\t\5\2\2\u141b\u141c\t\b\2\2\u141c\u141d\t") + buf.write("\7\2\2\u141d\u03e7\3\2\2\2\u141e\u141f\t\r\2\2\u141f\u1420") + buf.write("\t\4\2\2\u1420\u1421\t\13\2\2\u1421\u1422\t\5\2\2\u1422") + buf.write("\u1423\t\n\2\2\u1423\u1424\t\2\2\2\u1424\u1425\t\6\2\2") + buf.write("\u1425\u1426\t\n\2\2\u1426\u1427\t\16\2\2\u1427\u1428") + buf.write("\t\3\2\2\u1428\u03e9\3\2\2\2\u1429\u142a\t\r\2\2\u142a") + buf.write("\u142b\t\4\2\2\u142b\u142c\t\13\2\2\u142c\u142d\t\5\2") + buf.write("\2\u142d\u142e\t\n\2\2\u142e\u142f\t\2\2\2\u142f\u1430") + buf.write("\t\6\2\2\u1430\u1431\t\n\2\2\u1431\u1432\t\5\2\2\u1432") + buf.write("\u1433\t\4\2\2\u1433\u1434\t\b\2\2\u1434\u1435\t\n\2\2") + buf.write("\u1435\u03eb\3\2\2\2\u1436\u1437\t\r\2\2\u1437\u1438\t") + buf.write("\4\2\2\u1438\u1439\t\f\2\2\u1439\u143a\t\r\2\2\u143a\u143b") + buf.write("\t\24\2\2\u143b\u143c\t\n\2\2\u143c\u143d\t\5\2\2\u143d") + buf.write("\u143e\t\f\2\2\u143e\u143f\t\6\2\2\u143f\u03ed\3\2\2\2") + buf.write("\u1440\u1441\t\r\2\2\u1441\u1442\t\4\2\2\u1442\u1443\t") + buf.write("\b\2\2\u1443\u1444\t\4\2\2\u1444\u1445\t\21\2\2\u1445") + buf.write("\u1446\t\f\2\2\u1446\u1447\t\r\2\2\u1447\u03ef\3\2\2\2") + buf.write("\u1448\u1449\t\r\2\2\u1449\u144a\t\4\2\2\u144a\u144b\t") + buf.write("\5\2\2\u144b\u144c\t\n\2\2\u144c\u144d\t\26\2\2\u144d") + buf.write("\u144e\t\b\2\2\u144e\u144f\t\f\2\2\u144f\u1450\t\13\2") + buf.write("\2\u1450\u1451\t\2\2\2\u1451\u1452\t\6\2\2\u1452\u1453") + buf.write("\t\f\2\2\u1453\u1454\t\4\2\2\u1454\u1455\t\r\2\2\u1455") + buf.write("\u03f1\3\2\2\2\u1456\u1457\t\r\2\2\u1457\u1458\t\4\2\2") + buf.write("\u1458\u1459\t\7\2\2\u1459\u145a\t\t\2\2\u145a\u145b\t") + buf.write("\26\2\2\u145b\u145c\t\n\2\2\u145c\u145d\t\5\2\2\u145d") + buf.write("\u145e\t\t\2\2\u145e\u145f\t\7\2\2\u145f\u1460\t\n\2\2") + buf.write("\u1460\u1461\t\5\2\2\u1461\u03f3\3\2\2\2\u1462\u1463\t") + buf.write("\4\2\2\u1463\u1464\t\t\2\2\u1464\u1465\t\6\2\2\u1465\u1466") + buf.write("\t\26\2\2\u1466\u1467\t\t\2\2\u1467\u1468\t\6\2\2\u1468") + buf.write("\u03f5\3\2\2\2\u1469\u146a\t\26\2\2\u146a\u146b\t\2\2") + buf.write("\2\u146b\u146c\t\7\2\2\u146c\u146d\t\7\2\2\u146d\u146e") + buf.write("\t\n\2\2\u146e\u146f\t\16\2\2\u146f\u1470\t\3\2\2\u1470") + buf.write("\u1471\t\23\2\2\u1471\u1472\t\27\2\2\u1472\u1473\t\2\2") + buf.write("\2\u1473\u1474\t\b\2\2\u1474\u1475\t\t\2\2\u1475\u1476") + buf.write("\t\n\2\2\u1476\u03f7\3\2\2\2\u1477\u1478\t\26\2\2\u1478") + buf.write("\u1479\t\2\2\2\u1479\u147a\t\6\2\2\u147a\u147b\t\24\2") + buf.write("\2\u147b\u03f9\3\2\2\2\u147c\u147d\t\26\2\2\u147d\u147e") + buf.write("\t\n\2\2\u147e\u147f\t\5\2\2\u147f\u1480\t\17\2\2\u1480") + buf.write("\u1481\t\f\2\2\u1481\u1482\t\7\2\2\u1482\u1483\t\7\2\2") + buf.write("\u1483\u1484\t\f\2\2\u1484\u1485\t\27\2\2\u1485\u1486") + buf.write("\t\n\2\2\u1486\u03fb\3\2\2\2\u1487\u1488\t\26\2\2\u1488") + buf.write("\u1489\t\b\2\2\u1489\u148a\t\2\2\2\u148a\u148b\t\f\2\2") + buf.write("\u148b\u148c\t\r\2\2\u148c\u03fd\3\2\2\2\u148d\u148e\t") + buf.write("\26\2\2\u148e\u148f\t\5\2\2\u148f\u1490\t\n\2\2\u1490") + buf.write("\u1491\t\20\2\2\u1491\u1492\t\n\2\2\u1492\u1493\t\5\2") + buf.write("\2\u1493\u1494\t\5\2\2\u1494\u1495\t\n\2\2\u1495\u1496") + buf.write("\t\16\2\2\u1496\u03ff\3\2\2\2\u1497\u1498\t\26\2\2\u1498") + buf.write("\u1499\t\5\2\2\u1499\u149a\t\4\2\2\u149a\u149b\t\27\2") + buf.write("\2\u149b\u149c\t\f\2\2\u149c\u149d\t\16\2\2\u149d\u149e") + buf.write("\t\n\2\2\u149e\u149f\t\5\2\2\u149f\u0401\3\2\2\2\u14a0") + buf.write("\u14a1\5\u017e\u00bf\2\u14a1\u14a2\5\u0480\u0240\2\u14a2") + buf.write("\u14a3\5\u0346\u01a3\2\u14a3\u0403\3\2\2\2\u14a4\u14a5") + buf.write("\5\u017e\u00bf\2\u14a5\u14a6\5\u0480\u0240\2\u14a6\u14a7") + buf.write("\5\u0242\u0121\2\u14a7\u0405\3\2\2\2\u14a8\u14a9\t\5\2") + buf.write("\2\u14a9\u14aa\t\n\2\2\u14aa\u14ab\t\13\2\2\u14ab\u14ac") + buf.write("\t\n\2\2\u14ac\u14ad\t\f\2\2\u14ad\u14ae\t\27\2\2\u14ae") + buf.write("\u14af\t\n\2\2\u14af\u0407\3\2\2\2\u14b0\u14b1\t\5\2\2") + buf.write("\u14b1\u14b2\t\n\2\2\u14b2\u14b3\t\17\2\2\u14b3\u14b4") + buf.write("\t\2\2\2\u14b4\u14b5\t\f\2\2\u14b5\u14b6\t\r\2\2\u14b6") + buf.write("\u14b7\t\16\2\2\u14b7\u14b8\t\n\2\2\u14b8\u14b9\t\5\2") + buf.write("\2\u14b9\u0409\3\2\2\2\u14ba\u14bb\t\5\2\2\u14bb\u14bc") + buf.write("\t\n\2\2\u14bc\u14bd\t\26\2\2\u14bd\u14be\t\b\2\2\u14be") + buf.write("\u14bf\t\f\2\2\u14bf\u14c0\t\13\2\2\u14c0\u14c1\t\2\2") + buf.write("\2\u14c1\u14c2\t\6\2\2\u14c2\u14c3\t\f\2\2\u14c3\u14c4") + buf.write("\t\4\2\2\u14c4\u14c5\t\r\2\2\u14c5\u040b\3\2\2\2\u14c6") + buf.write("\u14c7\t\5\2\2\u14c7\u14c8\t\n\2\2\u14c8\u14c9\t\7\2\2") + buf.write("\u14c9\u14ca\t\6\2\2\u14ca\u14cb\t\5\2\2\u14cb\u14cc\t") + buf.write("\f\2\2\u14cc\u14cd\t\13\2\2\u14cd\u14ce\t\6\2\2\u14ce") + buf.write("\u14cf\t\n\2\2\u14cf\u14d0\t\16\2\2\u14d0\u040d\3\2\2") + buf.write("\2\u14d1\u14d2\t\5\2\2\u14d2\u14d3\t\n\2\2\u14d3\u14d4") + buf.write("\t\7\2\2\u14d4\u14d5\t\6\2\2\u14d5\u14d6\t\5\2\2\u14d6") + buf.write("\u14d7\t\f\2\2\u14d7\u14d8\t\13\2\2\u14d8\u14d9\t\6\2") + buf.write("\2\u14d9\u14da\t\f\2\2\u14da\u14db\t\27\2\2\u14db\u14dc") + buf.write("\t\n\2\2\u14dc\u040f\3\2\2\2\u14dd\u14de\t\5\2\2\u14de") + buf.write("\u14df\t\f\2\2\u14df\u14e0\t\21\2\2\u14e0\u14e1\t\24\2") + buf.write("\2\u14e1\u14e2\t\6\2\2\u14e2\u14e3\t\2\2\2\u14e3\u14e4") + buf.write("\t\5\2\2\u14e4\u14e5\t\21\2\2\u14e5\u0411\3\2\2\2\u14e6") + buf.write("\u14e7\t\7\2\2\u14e7\u14e8\t\2\2\2\u14e8\u14e9\t\20\2") + buf.write("\2\u14e9\u14ea\t\n\2\2\u14ea\u0413\3\2\2\2\u14eb\u14ec") + buf.write("\t\7\2\2\u14ec\u14ed\t\n\2\2\u14ed\u14ee\t\r\2\2\u14ee") + buf.write("\u14ef\t\16\2\2\u14ef\u0415\3\2\2\2\u14f0\u14f1\t\7\2") + buf.write("\2\u14f1\u14f2\t\n\2\2\u14f2\u14f3\t\5\2\2\u14f3\u14f4") + buf.write("\t\f\2\2\u14f4\u14f5\t\2\2\2\u14f5\u14f6\t\b\2\2\u14f6") + buf.write("\u14f7\t\20\2\2\u14f7\u14f8\t\t\2\2\u14f8\u14f9\t\r\2") + buf.write("\2\u14f9\u14fa\t\13\2\2\u14fa\u0417\3\2\2\2\u14fb\u14fc") + buf.write("\t\7\2\2\u14fc\u14fd\t\n\2\2\u14fd\u14fe\t\6\2\2\u14fe") + buf.write("\u14ff\t\6\2\2\u14ff\u1500\t\f\2\2\u1500\u1501\t\r\2\2") + buf.write("\u1501\u1502\t\21\2\2\u1502\u1503\t\7\2\2\u1503\u0419") + buf.write("\3\2\2\2\u1504\u1505\t\7\2\2\u1505\u1506\t\20\2\2\u1506") + buf.write("\u1507\t\t\2\2\u1507\u1508\t\r\2\2\u1508\u1509\t\13\2") + buf.write("\2\u1509\u041b\3\2\2\2\u150a\u150b\t\7\2\2\u150b\u150c") + buf.write("\t\24\2\2\u150c\u150d\t\2\2\2\u150d\u150e\t\5\2\2\u150e") + buf.write("\u150f\t\n\2\2\u150f\u1510\t\2\2\2\u1510\u1511\t\3\2\2") + buf.write("\u1511\u1512\t\b\2\2\u1512\u1513\t\n\2\2\u1513\u041d\3") + buf.write("\2\2\2\u1514\u1515\t\7\2\2\u1515\u1516\t\25\2\2\u1516") + buf.write("\u1517\t\f\2\2\u1517\u1518\t\26\2\2\u1518\u1519\5\u0480") + buf.write("\u0240\2\u1519\u151a\t\b\2\2\u151a\u151b\t\4\2\2\u151b") + buf.write("\u151c\t\13\2\2\u151c\u151d\t\25\2\2\u151d\u151e\t\n\2") + buf.write("\2\u151e\u151f\t\16\2\2\u151f\u041f\3\2\2\2\u1520\u1521") + buf.write("\t\7\2\2\u1521\u1522\t\4\2\2\u1522\u1523\t\5\2\2\u1523") + buf.write("\u1524\t\6\2\2\u1524\u1525\t\4\2\2\u1525\u1526\t\26\2") + buf.write("\2\u1526\u0421\3\2\2\2\u1527\u1528\t\7\2\2\u1528\u1529") + buf.write("\t\7\2\2\u1529\u152a\t\26\2\2\u152a\u152b\t\2\2\2\u152b") + buf.write("\u152c\t\13\2\2\u152c\u152d\t\n\2\2\u152d\u0423\3\2\2") + buf.write("\2\u152e\u152f\t\7\2\2\u152f\u1530\t\6\2\2\u1530\u1531") + buf.write("\t\23\2\2\u1531\u1532\t\26\2\2\u1532\u1533\t\n\2\2\u1533") + buf.write("\u0425\3\2\2\2\u1534\u1535\t\7\2\2\u1535\u1536\t\t\2\2") + buf.write("\u1536\u1537\t\3\2\2\u1537\u1538\t\6\2\2\u1538\u1539\t") + buf.write("\23\2\2\u1539\u153a\t\26\2\2\u153a\u153b\t\n\2\2\u153b") + buf.write("\u153c\5\u0480\u0240\2\u153c\u153d\t\16\2\2\u153d\u153e") + buf.write("\t\f\2\2\u153e\u153f\t\20\2\2\u153f\u1540\t\20\2\2\u1540") + buf.write("\u0427\3\2\2\2\u1541\u1542\t\7\2\2\u1542\u1543\t\t\2\2") + buf.write("\u1543\u1544\t\3\2\2\u1544\u1545\t\6\2\2\u1545\u1546\t") + buf.write("\23\2\2\u1546\u1547\t\26\2\2\u1547\u1548\t\n\2\2\u1548") + buf.write("\u1549\5\u0480\u0240\2\u1549\u154a\t\4\2\2\u154a\u154b") + buf.write("\t\26\2\2\u154b\u154c\t\13\2\2\u154c\u154d\t\b\2\2\u154d") + buf.write("\u154e\t\2\2\2\u154e\u154f\t\7\2\2\u154f\u1550\t\7\2\2") + buf.write("\u1550\u0429\3\2\2\2\u1551\u1552\t\7\2\2\u1552\u1553\t") + buf.write("\t\2\2\u1553\u1554\t\3\2\2\u1554\u1555\t\6\2\2\u1555\u1556") + buf.write("\t\23\2\2\u1556\u1557\t\26\2\2\u1557\u1558\t\n\2\2\u1558") + buf.write("\u042b\3\2\2\2\u1559\u155a\t\7\2\2\u155a\u155b\t\t\2\2") + buf.write("\u155b\u155c\t\17\2\2\u155c\u155d\t\17\2\2\u155d\u155e") + buf.write("\t\2\2\2\u155e\u155f\t\5\2\2\u155f\u1560\t\23\2\2\u1560") + buf.write("\u042d\3\2\2\2\u1561\u1562\t\7\2\2\u1562\u1563\t\t\2\2") + buf.write("\u1563\u1564\t\26\2\2\u1564\u1565\t\n\2\2\u1565\u1566") + buf.write("\t\5\2\2\u1566\u1567\t\t\2\2\u1567\u1568\t\7\2\2\u1568") + buf.write("\u1569\t\n\2\2\u1569\u156a\t\5\2\2\u156a\u042f\3\2\2\2") + buf.write("\u156b\u156c\t\6\2\2\u156c\u156d\t\f\2\2\u156d\u156e\t") + buf.write("\17\2\2\u156e\u156f\t\f\2\2\u156f\u1570\t\r\2\2\u1570") + buf.write("\u1571\t\21\2\2\u1571\u0431\3\2\2\2\u1572\u1573\t\6\2") + buf.write("\2\u1573\u1574\t\23\2\2\u1574\u1575\t\26\2\2\u1575\u1576") + buf.write("\t\17\2\2\u1576\u1577\t\4\2\2\u1577\u1578\t\16\2\2\u1578") + buf.write("\u1579\5\u0480\u0240\2\u1579\u157a\t\f\2\2\u157a\u157b") + buf.write("\t\r\2\2\u157b\u0433\3\2\2\2\u157c\u157d\t\6\2\2\u157d") + buf.write("\u157e\t\23\2\2\u157e\u157f\t\26\2\2\u157f\u1580\t\17") + buf.write("\2\2\u1580\u1581\t\4\2\2\u1581\u1582\t\16\2\2\u1582\u1583") + buf.write("\5\u0480\u0240\2\u1583\u1584\t\4\2\2\u1584\u1585\t\t\2") + buf.write("\2\u1585\u1586\t\6\2\2\u1586\u0435\3\2\2\2\u1587\u1588") + buf.write("\t\t\2\2\u1588\u1589\t\r\2\2\u1589\u158a\t\7\2\2\u158a") + buf.write("\u158b\t\2\2\2\u158b\u158c\t\20\2\2\u158c\u158d\t\n\2") + buf.write("\2\u158d\u0437\3\2\2\2\u158e\u158f\t\t\2\2\u158f\u1590") + buf.write("\t\7\2\2\u1590\u1591\t\2\2\2\u1591\u1592\t\21\2\2\u1592") + buf.write("\u1593\t\n\2\2\u1593\u0439\3\2\2\2\u1594\u1595\t\27\2") + buf.write("\2\u1595\u1596\t\2\2\2\u1596\u1597\t\5\2\2\u1597\u1598") + buf.write("\t\f\2\2\u1598\u1599\t\2\2\2\u1599\u159a\t\3\2\2\u159a") + buf.write("\u159b\t\b\2\2\u159b\u159c\t\n\2\2\u159c\u043b\3\2\2\2") + buf.write("\u159d\u159e\t\23\2\2\u159e\u159f\t\2\2\2\u159f\u15a0") + buf.write("\t\17\2\2\u15a0\u15a1\t\b\2\2\u15a1\u043d\3\2\2\2\u15a2") + buf.write("\u15a3\t\2\2\2\u15a3\u15a4\t\b\2\2\u15a4\u15a5\t\f\2\2") + buf.write("\u15a5\u15a6\t\2\2\2\u15a6\u15a7\t\7\2\2\u15a7\u043f\3") + buf.write("\2\2\2\u15a8\u15a9\t\2\2\2\u15a9\u15aa\t\7\2\2\u15aa\u15ab") + buf.write("\t\7\2\2\u15ab\u15ac\t\n\2\2\u15ac\u15ad\t\5\2\2\u15ad") + buf.write("\u15ae\t\6\2\2\u15ae\u0441\3\2\2\2\u15af\u15b0\t\13\2") + buf.write("\2\u15b0\u15b1\t\4\2\2\u15b1\u15b2\t\r\2\2\u15b2\u15b3") + buf.write("\t\7\2\2\u15b3\u15b4\t\6\2\2\u15b4\u15b5\t\2\2\2\u15b5") + buf.write("\u15b6\t\r\2\2\u15b6\u15b7\t\6\2\2\u15b7\u0443\3\2\2\2") + buf.write("\u15b8\u15b9\t\16\2\2\u15b9\u15ba\t\2\2\2\u15ba\u15bb") + buf.write("\t\6\2\2\u15bb\u15bc\t\2\2\2\u15bc\u15bd\t\6\2\2\u15bd") + buf.write("\u15be\t\23\2\2\u15be\u15bf\t\26\2\2\u15bf\u15c0\t\n\2") + buf.write("\2\u15c0\u0445\3\2\2\2\u15c1\u15c2\t\16\2\2\u15c2\u15c3") + buf.write("\t\n\2\2\u15c3\u15c4\t\3\2\2\u15c4\u15c5\t\t\2\2\u15c5") + buf.write("\u15c6\t\21\2\2\u15c6\u0447\3\2\2\2\u15c7\u15c8\t\16\2") + buf.write("\2\u15c8\u15c9\t\n\2\2\u15c9\u15ca\t\6\2\2\u15ca\u15cb") + buf.write("\t\2\2\2\u15cb\u15cc\t\f\2\2\u15cc\u15cd\t\b\2\2\u15cd") + buf.write("\u0449\3\2\2\2\u15ce\u15cf\t\16\2\2\u15cf\u15d0\t\f\2") + buf.write("\2\u15d0\u15d1\t\2\2\2\u15d1\u15d2\t\21\2\2\u15d2\u15d3") + buf.write("\t\r\2\2\u15d3\u15d4\t\4\2\2\u15d4\u15d5\t\7\2\2\u15d5") + buf.write("\u15d6\t\6\2\2\u15d6\u15d7\t\f\2\2\u15d7\u15d8\t\13\2") + buf.write("\2\u15d8\u15d9\t\7\2\2\u15d9\u044b\3\2\2\2\u15da\u15db") + buf.write("\t\n\2\2\u15db\u15dc\t\b\2\2\u15dc\u15dd\t\7\2\2\u15dd") + buf.write("\u15de\t\n\2\2\u15de\u15df\t\f\2\2\u15df\u15e0\t\20\2") + buf.write("\2\u15e0\u044d\3\2\2\2\u15e1\u15e2\t\n\2\2\u15e2\u15e3") + buf.write("\t\b\2\2\u15e3\u15e4\t\7\2\2\u15e4\u15e5\t\f\2\2\u15e5") + buf.write("\u15e6\t\20\2\2\u15e6\u044f\3\2\2\2\u15e7\u15e8\t\n\2") + buf.write("\2\u15e8\u15e9\t\5\2\2\u15e9\u15ea\t\5\2\2\u15ea\u15eb") + buf.write("\t\13\2\2\u15eb\u15ec\t\4\2\2\u15ec\u15ed\t\16\2\2\u15ed") + buf.write("\u15ee\t\n\2\2\u15ee\u0451\3\2\2\2\u15ef\u15f0\t\n\2\2") + buf.write("\u15f0\u15f1\t\30\2\2\u15f1\u15f2\t\f\2\2\u15f2\u15f3") + buf.write("\t\6\2\2\u15f3\u0453\3\2\2\2\u15f4\u15f5\t\n\2\2\u15f5") + buf.write("\u15f6\t\30\2\2\u15f6\u15f7\t\13\2\2\u15f7\u15f8\t\n\2") + buf.write("\2\u15f8\u15f9\t\26\2\2\u15f9\u15fa\t\6\2\2\u15fa\u15fb") + buf.write("\t\f\2\2\u15fb\u15fc\t\4\2\2\u15fc\u15fd\t\r\2\2\u15fd") + buf.write("\u0455\3\2\2\2\u15fe\u15ff\t\20\2\2\u15ff\u1600\t\4\2") + buf.write("\2\u1600\u1601\t\5\2\2\u1601\u1602\t\n\2\2\u1602\u1603") + buf.write("\t\2\2\2\u1603\u1604\t\13\2\2\u1604\u1605\t\24\2\2\u1605") + buf.write("\u0457\3\2\2\2\u1606\u1607\t\21\2\2\u1607\u1608\t\n\2") + buf.write("\2\u1608\u1609\t\6\2\2\u1609\u0459\3\2\2\2\u160a\u160b") + buf.write("\t\24\2\2\u160b\u160c\t\f\2\2\u160c\u160d\t\r\2\2\u160d") + buf.write("\u160e\t\6\2\2\u160e\u045b\3\2\2\2\u160f\u1610\t\f\2\2") + buf.write("\u1610\u1611\t\r\2\2\u1611\u1612\t\20\2\2\u1612\u1613") + buf.write("\t\4\2\2\u1613\u045d\3\2\2\2\u1614\u1615\t\b\2\2\u1615") + buf.write("\u1616\t\4\2\2\u1616\u1617\t\21\2\2\u1617\u045f\3\2\2") + buf.write("\2\u1618\u1619\t\b\2\2\u1619\u161a\t\4\2\2\u161a\u161b") + buf.write("\t\4\2\2\u161b\u161c\t\26\2\2\u161c\u0461\3\2\2\2\u161d") + buf.write("\u161e\t\17\2\2\u161e\u161f\t\n\2\2\u161f\u1620\t\7\2") + buf.write("\2\u1620\u1621\t\7\2\2\u1621\u1622\t\2\2\2\u1622\u1623") + buf.write("\t\21\2\2\u1623\u1624\t\n\2\2\u1624\u0463\3\2\2\2\u1625") + buf.write("\u1626\t\r\2\2\u1626\u1627\t\4\2\2\u1627\u1628\t\6\2\2") + buf.write("\u1628\u1629\t\f\2\2\u1629\u162a\t\13\2\2\u162a\u162b") + buf.write("\t\n\2\2\u162b\u0465\3\2\2\2\u162c\u162d\t\4\2\2\u162d") + buf.write("\u162e\t\26\2\2\u162e\u162f\t\n\2\2\u162f\u1630\t\r\2") + buf.write("\2\u1630\u0467\3\2\2\2\u1631\u1632\t\26\2\2\u1632\u1633") + buf.write("\t\n\2\2\u1633\u1634\t\5\2\2\u1634\u1635\t\20\2\2\u1635") + buf.write("\u1636\t\4\2\2\u1636\u1637\t\5\2\2\u1637\u1638\t\17\2") + buf.write("\2\u1638\u0469\3\2\2\2\u1639\u163a\t\33\2\2\u163a\u163b") + buf.write("\t\t\2\2\u163b\u163c\t\n\2\2\u163c\u163d\t\5\2\2\u163d") + buf.write("\u163e\t\23\2\2\u163e\u046b\3\2\2\2\u163f\u1640\t\5\2") + buf.write("\2\u1640\u1641\t\2\2\2\u1641\u1642\t\f\2\2\u1642\u1643") + buf.write("\t\7\2\2\u1643\u1644\t\n\2\2\u1644\u046d\3\2\2\2\u1645") + buf.write("\u1646\t\5\2\2\u1646\u1647\t\n\2\2\u1647\u1648\t\13\2") + buf.write("\2\u1648\u1649\t\4\2\2\u1649\u164a\t\5\2\2\u164a\u164b") + buf.write("\t\16\2\2\u164b\u046f\3\2\2\2\u164c\u164d\t\5\2\2\u164d") + buf.write("\u164e\t\n\2\2\u164e\u164f\t\6\2\2\u164f\u1650\t\t\2\2") + buf.write("\u1650\u1651\t\5\2\2\u1651\u1652\t\r\2\2\u1652\u0471\3") + buf.write("\2\2\2\u1653\u1654\t\5\2\2\u1654\u1655\t\n\2\2\u1655\u1656") + buf.write("\t\27\2\2\u1656\u1657\t\n\2\2\u1657\u1658\t\5\2\2\u1658") + buf.write("\u1659\t\7\2\2\u1659\u165a\t\n\2\2\u165a\u0473\3\2\2\2") + buf.write("\u165b\u165c\t\5\2\2\u165c\u165d\t\4\2\2\u165d\u165e\t") + buf.write("\22\2\2\u165e\u165f\t\6\2\2\u165f\u1660\t\23\2\2\u1660") + buf.write("\u1661\t\26\2\2\u1661\u1662\t\n\2\2\u1662\u0475\3\2\2") + buf.write("\2\u1663\u1664\t\7\2\2\u1664\u1665\t\b\2\2\u1665\u1666") + buf.write("\t\f\2\2\u1666\u1667\t\13\2\2\u1667\u1668\t\n\2\2\u1668") + buf.write("\u0477\3\2\2\2\u1669\u166a\t\7\2\2\u166a\u166b\t\33\2") + buf.write("\2\u166b\u166c\t\b\2\2\u166c\u166d\t\7\2\2\u166d\u166e") + buf.write("\t\6\2\2\u166e\u166f\t\2\2\2\u166f\u1670\t\6\2\2\u1670") + buf.write("\u1671\t\n\2\2\u1671\u0479\3\2\2\2\u1672\u1673\t\7\2\2") + buf.write("\u1673\u1674\t\6\2\2\u1674\u1675\t\2\2\2\u1675\u1676\t") + buf.write("\13\2\2\u1676\u1677\t\25\2\2\u1677\u1678\t\n\2\2\u1678") + buf.write("\u1679\t\16\2\2\u1679\u047b\3\2\2\2\u167a\u167b\t\22\2") + buf.write("\2\u167b\u167c\t\2\2\2\u167c\u167d\t\5\2\2\u167d\u167e") + buf.write("\t\r\2\2\u167e\u167f\t\f\2\2\u167f\u1680\t\r\2\2\u1680") + buf.write("\u1681\t\21\2\2\u1681\u047d\3\2\2\2\u1682\u1683\t\22\2") + buf.write("\2\u1683\u1684\t\24\2\2\u1684\u1685\t\f\2\2\u1685\u1686") + buf.write("\t\b\2\2\u1686\u1687\t\n\2\2\u1687\u047f\3\2\2\2\u1688") + buf.write("\u1689\7a\2\2\u1689\u0481\3\2\2\2\u168a\u168b\7<\2\2\u168b") + buf.write("\u168c\7<\2\2\u168c\u0483\3\2\2\2\u168d\u168e\7?\2\2\u168e") + buf.write("\u0485\3\2\2\2\u168f\u1690\7<\2\2\u1690\u0487\3\2\2\2") + buf.write("\u1691\u1692\7=\2\2\u1692\u0489\3\2\2\2\u1693\u1694\7") + buf.write(".\2\2\u1694\u048b\3\2\2\2\u1695\u1696\7>\2\2\u1696\u169a") + buf.write("\7@\2\2\u1697\u1698\7#\2\2\u1698\u169a\7?\2\2\u1699\u1695") + buf.write("\3\2\2\2\u1699\u1697\3\2\2\2\u169a\u048d\3\2\2\2\u169b") + buf.write("\u169c\7>\2\2\u169c\u048f\3\2\2\2\u169d\u169e\7>\2\2\u169e") + buf.write("\u169f\7?\2\2\u169f\u0491\3\2\2\2\u16a0\u16a1\7@\2\2\u16a1") + buf.write("\u0493\3\2\2\2\u16a2\u16a3\7@\2\2\u16a3\u16a4\7?\2\2\u16a4") + buf.write("\u0495\3\2\2\2\u16a5\u16a6\7*\2\2\u16a6\u0497\3\2\2\2") + buf.write("\u16a7\u16a8\7+\2\2\u16a8\u0499\3\2\2\2\u16a9\u16aa\7") + buf.write("-\2\2\u16aa\u049b\3\2\2\2\u16ab\u16ac\7/\2\2\u16ac\u049d") + buf.write("\3\2\2\2\u16ad\u16ae\7,\2\2\u16ae\u049f\3\2\2\2\u16af") + buf.write("\u16b0\7\61\2\2\u16b0\u04a1\3\2\2\2\u16b1\u16b2\7\'\2") + buf.write("\2\u16b2\u04a3\3\2\2\2\u16b3\u16b4\7`\2\2\u16b4\u04a5") + buf.write("\3\2\2\2\u16b5\u16b6\7\60\2\2\u16b6\u04a7\3\2\2\2\u16b7") + buf.write("\u16b8\7)\2\2\u16b8\u04a9\3\2\2\2\u16b9\u16ba\7$\2\2\u16ba") + buf.write("\u04ab\3\2\2\2\u16bb\u16bc\7&\2\2\u16bc\u04ad\3\2\2\2") + buf.write("\u16bd\u16be\7]\2\2\u16be\u04af\3\2\2\2\u16bf\u16c0\7") + buf.write("_\2\2\u16c0\u04b1\3\2\2\2\u16c1\u16c2\7?\2\2\u16c2\u16c3") + buf.write("\7@\2\2\u16c3\u04b3\3\2\2\2\u16c4\u16c5\7<\2\2\u16c5\u16c6") + buf.write("\7?\2\2\u16c6\u04b5\3\2\2\2\u16c7\u16c8\7>\2\2\u16c8\u16c9") + buf.write("\7>\2\2\u16c9\u04b7\3\2\2\2\u16ca\u16cb\7@\2\2\u16cb\u16cc") + buf.write("\7@\2\2\u16cc\u04b9\3\2\2\2\u16cd\u16ce\7\60\2\2\u16ce") + buf.write("\u16cf\7\60\2\2\u16cf\u04bb\3\2\2\2\u16d0\u16d1\7%\2\2") + buf.write("\u16d1\u04bd\3\2\2\2\u16d2\u16d3\7\61\2\2\u16d3\u16d4") + buf.write("\7,\2\2\u16d4\u16d9\3\2\2\2\u16d5\u16d8\5\u04be\u025f") + buf.write("\2\u16d6\u16d8\13\2\2\2\u16d7\u16d5\3\2\2\2\u16d7\u16d6") + buf.write("\3\2\2\2\u16d8\u16db\3\2\2\2\u16d9\u16da\3\2\2\2\u16d9") + buf.write("\u16d7\3\2\2\2\u16da\u16dc\3\2\2\2\u16db\u16d9\3\2\2\2") + buf.write("\u16dc\u16dd\7,\2\2\u16dd\u16de\7\61\2\2\u16de\u16df\3") + buf.write("\2\2\2\u16df\u16e0\b\u025f\2\2\u16e0\u04bf\3\2\2\2\u16e1") + buf.write("\u16e2\7/\2\2\u16e2\u16e3\7/\2\2\u16e3\u16e7\3\2\2\2\u16e4") + buf.write("\u16e6\n\34\2\2\u16e5\u16e4\3\2\2\2\u16e6\u16e9\3\2\2") + buf.write("\2\u16e7\u16e5\3\2\2\2\u16e7\u16e8\3\2\2\2\u16e8\u16ea") + buf.write("\3\2\2\2\u16e9\u16e7\3\2\2\2\u16ea\u16eb\b\u0260\2\2\u16eb") + buf.write("\u04c1\3\2\2\2\u16ec\u16ee\5\u04c4\u0262\2\u16ed\u16ec") + buf.write("\3\2\2\2\u16ee\u16ef\3\2\2\2\u16ef\u16ed\3\2\2\2\u16ef") + buf.write("\u16f0\3\2\2\2\u16f0\u16f1\3\2\2\2\u16f1\u16f2\5\u04c6") + buf.write("\u0263\2\u16f2\u1703\3\2\2\2\u16f3\u16f6\5\u04c4\u0262") + buf.write("\2\u16f4\u16f6\5\u04c8\u0264\2\u16f5\u16f3\3\2\2\2\u16f5") + buf.write("\u16f4\3\2\2\2\u16f6\u16f9\3\2\2\2\u16f7\u16f5\3\2\2\2") + buf.write("\u16f7\u16f8\3\2\2\2\u16f8\u16fa\3\2\2\2\u16f9\u16f7\3") + buf.write("\2\2\2\u16fa\u16ff\5\u04c8\u0264\2\u16fb\u16fe\5\u04c4") + buf.write("\u0262\2\u16fc\u16fe\5\u04c8\u0264\2\u16fd\u16fb\3\2\2") + buf.write("\2\u16fd\u16fc\3\2\2\2\u16fe\u1701\3\2\2\2\u16ff\u16fd") + buf.write("\3\2\2\2\u16ff\u1700\3\2\2\2\u1700\u1703\3\2\2\2\u1701") + buf.write("\u16ff\3\2\2\2\u1702\u16ed\3\2\2\2\u1702\u16f7\3\2\2\2") + buf.write("\u1703\u04c3\3\2\2\2\u1704\u170a\t\35\2\2\u1705\u1706") + buf.write("\7/\2\2\u1706\u170a\6\u0262\2\2\u1707\u1708\7\61\2\2\u1708") + buf.write("\u170a\6\u0262\3\2\u1709\u1704\3\2\2\2\u1709\u1705\3\2") + buf.write("\2\2\u1709\u1707\3\2\2\2\u170a\u04c5\3\2\2\2\u170b\u170c") + buf.write("\t\36\2\2\u170c\u04c7\3\2\2\2\u170d\u170e\t\37\2\2\u170e") + buf.write("\u04c9\3\2\2\2\u170f\u1711\5\u04cc\u0266\2\u1710\u170f") + buf.write("\3\2\2\2\u1711\u1712\3\2\2\2\u1712\u1710\3\2\2\2\u1712") + buf.write("\u1713\3\2\2\2\u1713\u04cb\3\2\2\2\u1714\u1715\4\62;\2") + buf.write("\u1715\u04cd\3\2\2\2\u1716\u1718\5\u04cc\u0266\2\u1717") + buf.write("\u1716\3\2\2\2\u1718\u1719\3\2\2\2\u1719\u1717\3\2\2\2") + buf.write("\u1719\u171a\3\2\2\2\u171a\u171b\3\2\2\2\u171b\u171c\7") + buf.write("\60\2\2\u171c\u171d\6\u0267\4\2\u171d\u1745\3\2\2\2\u171e") + buf.write("\u1720\5\u04cc\u0266\2\u171f\u171e\3\2\2\2\u1720\u1721") + buf.write("\3\2\2\2\u1721\u171f\3\2\2\2\u1721\u1722\3\2\2\2\u1722") + buf.write("\u1723\3\2\2\2\u1723\u1725\7\60\2\2\u1724\u1726\5\u04cc") + buf.write("\u0266\2\u1725\u1724\3\2\2\2\u1726\u1727\3\2\2\2\u1727") + buf.write("\u1725\3\2\2\2\u1727\u1728\3\2\2\2\u1728\u172a\3\2\2\2") + buf.write("\u1729\u172b\5\u04e8\u0274\2\u172a\u1729\3\2\2\2\u172a") + buf.write("\u172b\3\2\2\2\u172b\u1745\3\2\2\2\u172c\u172e\5\u04cc") + buf.write("\u0266\2\u172d\u172c\3\2\2\2\u172e\u172f\3\2\2\2\u172f") + buf.write("\u172d\3\2\2\2\u172f\u1730\3\2\2\2\u1730\u1731\3\2\2\2") + buf.write("\u1731\u1732\7\60\2\2\u1732\u1733\5\u04e8\u0274\2\u1733") + buf.write("\u1745\3\2\2\2\u1734\u1736\7\60\2\2\u1735\u1737\5\u04cc") + buf.write("\u0266\2\u1736\u1735\3\2\2\2\u1737\u1738\3\2\2\2\u1738") + buf.write("\u1736\3\2\2\2\u1738\u1739\3\2\2\2\u1739\u173b\3\2\2\2") + buf.write("\u173a\u173c\5\u04e8\u0274\2\u173b\u173a\3\2\2\2\u173b") + buf.write("\u173c\3\2\2\2\u173c\u1745\3\2\2\2\u173d\u173f\5\u04cc") + buf.write("\u0266\2\u173e\u173d\3\2\2\2\u173f\u1740\3\2\2\2\u1740") + buf.write("\u173e\3\2\2\2\u1740\u1741\3\2\2\2\u1741\u1742\3\2\2\2") + buf.write("\u1742\u1743\5\u04e8\u0274\2\u1743\u1745\3\2\2\2\u1744") + buf.write("\u1717\3\2\2\2\u1744\u171f\3\2\2\2\u1744\u172d\3\2\2\2") + buf.write("\u1744\u1734\3\2\2\2\u1744\u173e\3\2\2\2\u1745\u04cf\3") + buf.write("\2\2\2\u1746\u1747\5\u04ac\u0256\2\u1747\u1748\5\u04ca") + buf.write("\u0265\2\u1748\u04d1\3\2\2\2\u1749\u174d\5\u04d4\u026a") + buf.write("\2\u174a\u174c\5\u04d6\u026b\2\u174b\u174a\3\2\2\2\u174c") + buf.write("\u174f\3\2\2\2\u174d\u174b\3\2\2\2\u174d\u174e\3\2\2\2") + buf.write("\u174e\u1750\3\2\2\2\u174f\u174d\3\2\2\2\u1750\u1751\b") + buf.write("\u0269\3\2\u1751\u04d3\3\2\2\2\u1752\u1759\t \2\2\u1753") + buf.write("\u1754\t!\2\2\u1754\u1759\6\u026a\5\2\u1755\u1756\t\"") + buf.write("\2\2\u1756\u1757\t#\2\2\u1757\u1759\6\u026a\6\2\u1758") + buf.write("\u1752\3\2\2\2\u1758\u1753\3\2\2\2\u1758\u1755\3\2\2\2") + buf.write("\u1759\u04d5\3\2\2\2\u175a\u175d\5\u04d8\u026c\2\u175b") + buf.write("\u175d\7&\2\2\u175c\u175a\3\2\2\2\u175c\u175b\3\2\2\2") + buf.write("\u175d\u04d7\3\2\2\2\u175e\u1761\5\u04d4\u026a\2\u175f") + buf.write("\u1761\t$\2\2\u1760\u175e\3\2\2\2\u1760\u175f\3\2\2\2") + buf.write("\u1761\u04d9\3\2\2\2\u1762\u1763\5\u04dc\u026e\2\u1763") + buf.write("\u1764\7$\2\2\u1764\u1765\b\u026d\4\2\u1765\u04db\3\2") + buf.write("\2\2\u1766\u176c\7$\2\2\u1767\u1768\7$\2\2\u1768\u176b") + buf.write("\7$\2\2\u1769\u176b\n%\2\2\u176a\u1767\3\2\2\2\u176a\u1769") + buf.write("\3\2\2\2\u176b\u176e\3\2\2\2\u176c\u176a\3\2\2\2\u176c") + buf.write("\u176d\3\2\2\2\u176d\u04dd\3\2\2\2\u176e\u176c\3\2\2\2") + buf.write("\u176f\u1770\t&\2\2\u1770\u04df\3\2\2\2\u1771\u1772\4") + buf.write("\u0082\u00a1\2\u1772\u04e1\3\2\2\2\u1773\u1775\t\'\2\2") + buf.write("\u1774\u1773\3\2\2\2\u1774\u1775\3\2\2\2\u1775\u1776\3") + buf.write("\2\2\2\u1776\u177c\5\u04e4\u0272\2\u1777\u1778\5\u04e6") + buf.write("\u0273\2\u1778\u1779\5\u04e4\u0272\2\u1779\u177b\3\2\2") + buf.write("\2\u177a\u1777\3\2\2\2\u177b\u177e\3\2\2\2\u177c\u177a") + buf.write("\3\2\2\2\u177c\u177d\3\2\2\2\u177d\u04e3\3\2\2\2\u177e") + buf.write("\u177c\3\2\2\2\u177f\u1785\5\u04a8\u0254\2\u1780\u1784") + buf.write("\n(\2\2\u1781\u1782\7)\2\2\u1782\u1784\7)\2\2\u1783\u1780") + buf.write("\3\2\2\2\u1783\u1781\3\2\2\2\u1784\u1787\3\2\2\2\u1785") + buf.write("\u1783\3\2\2\2\u1785\u1786\3\2\2\2\u1786\u1788\3\2\2\2") + buf.write("\u1787\u1785\3\2\2\2\u1788\u1789\5\u04a8\u0254\2\u1789") + buf.write("\u04e5\3\2\2\2\u178a\u178f\5\u04ee\u0277\2\u178b\u178f") + buf.write("\5\u04f4\u027a\2\u178c\u178f\5\u04f0\u0278\2\u178d\u178f") + buf.write("\5\u04c0\u0260\2\u178e\u178a\3\2\2\2\u178e\u178b\3\2\2") + buf.write("\2\u178e\u178c\3\2\2\2\u178e\u178d\3\2\2\2\u178f\u1792") + buf.write("\3\2\2\2\u1790\u178e\3\2\2\2\u1790\u1791\3\2\2\2\u1791") + buf.write("\u1793\3\2\2\2\u1792\u1790\3\2\2\2\u1793\u1795\5\u04f2") + buf.write("\u0279\2\u1794\u1790\3\2\2\2\u1795\u1796\3\2\2\2\u1796") + buf.write("\u1794\3\2\2\2\u1796\u1797\3\2\2\2\u1797\u179d\3\2\2\2") + buf.write("\u1798\u179c\5\u04ee\u0277\2\u1799\u179c\5\u04f4\u027a") + buf.write("\2\u179a\u179c\5\u04f0\u0278\2\u179b\u1798\3\2\2\2\u179b") + buf.write("\u1799\3\2\2\2\u179b\u179a\3\2\2\2\u179c\u179f\3\2\2\2") + buf.write("\u179d\u179b\3\2\2\2\u179d\u179e\3\2\2\2\u179e\u04e7\3") + buf.write("\2\2\2\u179f\u179d\3\2\2\2\u17a0\u17a2\t\n\2\2\u17a1\u17a3") + buf.write("\t)\2\2\u17a2\u17a1\3\2\2\2\u17a2\u17a3\3\2\2\2\u17a3") + buf.write("\u17a5\3\2\2\2\u17a4\u17a6\5\u04cc\u0266\2\u17a5\u17a4") + buf.write("\3\2\2\2\u17a6\u17a7\3\2\2\2\u17a7\u17a5\3\2\2\2\u17a7") + buf.write("\u17a8\3\2\2\2\u17a8\u04e9\3\2\2\2\u17a9\u17ab\7&\2\2") + buf.write("\u17aa\u17ac\5\u04ec\u0276\2\u17ab\u17aa\3\2\2\2\u17ab") + buf.write("\u17ac\3\2\2\2\u17ac\u17ad\3\2\2\2\u17ad\u17ae\7&\2\2") + buf.write("\u17ae\u17af\b\u0275\5\2\u17af\u17b0\3\2\2\2\u17b0\u17b1") + buf.write("\b\u0275\6\2\u17b1\u04eb\3\2\2\2\u17b2\u17b6\5\u04d4\u026a") + buf.write("\2\u17b3\u17b5\5\u04d8\u026c\2\u17b4\u17b3\3\2\2\2\u17b5") + buf.write("\u17b8\3\2\2\2\u17b6\u17b4\3\2\2\2\u17b6\u17b7\3\2\2\2") + buf.write("\u17b7\u04ed\3\2\2\2\u17b8\u17b6\3\2\2\2\u17b9\u17ba\7") + buf.write("\"\2\2\u17ba\u17bb\3\2\2\2\u17bb\u17bc\b\u0277\2\2\u17bc") + buf.write("\u04ef\3\2\2\2\u17bd\u17c0\5\u04de\u026f\2\u17be\u17c0") + buf.write("\5\u04e0\u0270\2\u17bf\u17bd\3\2\2\2\u17bf\u17be\3\2\2") + buf.write("\2\u17c0\u17c1\3\2\2\2\u17c1\u17bf\3\2\2\2\u17c1\u17c2") + buf.write("\3\2\2\2\u17c2\u17c3\3\2\2\2\u17c3\u17c4\b\u0278\2\2\u17c4") + buf.write("\u04f1\3\2\2\2\u17c5\u17cb\7\17\2\2\u17c6\u17c8\7\17\2") + buf.write("\2\u17c7\u17c6\3\2\2\2\u17c7\u17c8\3\2\2\2\u17c8\u17c9") + buf.write("\3\2\2\2\u17c9\u17cb\7\f\2\2\u17ca\u17c5\3\2\2\2\u17ca") + buf.write("\u17c7\3\2\2\2\u17cb\u17cc\3\2\2\2\u17cc\u17cd\b\u0279") + buf.write("\2\2\u17cd\u04f3\3\2\2\2\u17ce\u17cf\7\13\2\2\u17cf\u17d0") + buf.write("\3\2\2\2\u17d0\u17d1\b\u027a\2\2\u17d1\u04f5\3\2\2\2\u17d2") + buf.write("\u17d3\7\uff01\2\2\u17d3\u04f7\3\2\2\2\u17d4\u17d5\13") + buf.write("\2\2\2\u17d5\u04f9\3\2\2\2\u17d6\u17d8\n*\2\2\u17d7\u17d6") + buf.write("\3\2\2\2\u17d8\u17d9\3\2\2\2\u17d9\u17d7\3\2\2\2\u17d9") + buf.write("\u17da\3\2\2\2\u17da\u17e3\3\2\2\2\u17db\u17df\7&\2\2") + buf.write("\u17dc\u17de\n*\2\2\u17dd\u17dc\3\2\2\2\u17de\u17e1\3") + buf.write("\2\2\2\u17df\u17dd\3\2\2\2\u17df\u17e0\3\2\2\2\u17e0\u17e3") + buf.write("\3\2\2\2\u17e1\u17df\3\2\2\2\u17e2\u17d7\3\2\2\2\u17e2") + buf.write("\u17db\3\2\2\2\u17e3\u04fb\3\2\2\2\u17e4\u17e6\7&\2\2") + buf.write("\u17e5\u17e7\5\u04ec\u0276\2\u17e6\u17e5\3\2\2\2\u17e6") + buf.write("\u17e7\3\2\2\2\u17e7\u17e8\3\2\2\2\u17e8\u17e9\7&\2\2") + buf.write("\u17e9\u17ea\6\u027e\7\2\u17ea\u17eb\b\u027e\7\2\u17eb") + buf.write("\u17ec\3\2\2\2\u17ec\u17ed\b\u027e\b\2\u17ed\u04fd\3\2") + buf.write("\2\2\64\2\3\u1699\u16d7\u16d9\u16e7\u16ef\u16f5\u16f7") + buf.write("\u16fd\u16ff\u1702\u1709\u1712\u1719\u1721\u1727\u172a") + buf.write("\u172f\u1738\u173b\u1740\u1744\u174d\u1758\u175c\u1760") + buf.write("\u176a\u176c\u1774\u177c\u1783\u1785\u178e\u1790\u1796") + buf.write("\u179b\u179d\u17a2\u17a7\u17ab\u17b6\u17bf\u17c1\u17c7") + buf.write("\u17ca\u17d9\u17df\u17e2\u17e6\t\2\3\2\3\u0269\2\3\u026d") + buf.write("\3\3\u0275\4\7\3\2\3\u027e\5\6\2\2") + return buf.getvalue() + + +class PLpgSQLLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + DollarQuotedStringMode = 1 + + ABORT = 1 + ABSOLUTE = 2 + ACCESS = 3 + ACTION = 4 + ADD = 5 + ADMIN = 6 + AFTER = 7 + AGGREGATE = 8 + ALSO = 9 + ALTER = 10 + ALWAYS = 11 + ASSERTION = 12 + ASSIGNMENT = 13 + AT = 14 + ATTACH = 15 + ATTRIBUTE = 16 + BACKWARD = 17 + BEFORE = 18 + BEGIN = 19 + BY = 20 + CACHE = 21 + CALL = 22 + CALLED = 23 + CASCADE = 24 + CASCADED = 25 + CATALOG = 26 + CHAIN = 27 + CHARACTERISTICS = 28 + CHECKPOINT = 29 + CLASS = 30 + CLOSE = 31 + CLUSTER = 32 + COLUMNS = 33 + COMMENT = 34 + COMMENTS = 35 + COMMIT = 36 + COMMITTED = 37 + CONFIGURATION = 38 + CONFLICT = 39 + CONNECTION = 40 + CONSTRAINTS = 41 + CONTENT = 42 + CONTINUE = 43 + CONVERSION = 44 + COPY = 45 + COST = 46 + CSV = 47 + CUBE = 48 + CURRENT = 49 + CURSOR = 50 + CYCLE = 51 + DATA = 52 + DATABASE = 53 + DAY = 54 + DEALLOCATE = 55 + DECLARE = 56 + DEFAULTS = 57 + DEFERRED = 58 + DEFINER = 59 + DELETE = 60 + DELIMITER = 61 + DELIMITERS = 62 + DEPENDS = 63 + DETACH = 64 + DICTIONARY = 65 + DISABLE = 66 + DISCARD = 67 + DOCUMENT = 68 + DOMAIN = 69 + DOUBLE = 70 + DROP = 71 + EACH = 72 + ENABLE = 73 + ENCODING = 74 + ENCRYPTED = 75 + ENUM = 76 + ESCAPE = 77 + EVENT = 78 + EXCLUDE = 79 + EXCLUDING = 80 + EXCLUSIVE = 81 + EXECUTE = 82 + EXPLAIN = 83 + EXTENSION = 84 + EXTERNAL = 85 + FAMILY = 86 + FILTER = 87 + FIRST = 88 + FOLLOWING = 89 + FORCE = 90 + FORWARD = 91 + FUNCTION = 92 + FUNCTIONS = 93 + GENERATED = 94 + GLOBAL = 95 + GRANTED = 96 + GROUPS = 97 + HANDLER = 98 + HEADER = 99 + HOLD = 100 + HOUR = 101 + IDENTITY = 102 + IF = 103 + IMMEDIATE = 104 + IMMUTABLE = 105 + IMPLICIT = 106 + IMPORT = 107 + INCLUDE = 108 + INCLUDING = 109 + INCREMENT = 110 + INDEX = 111 + INDEXES = 112 + INHERIT = 113 + INHERITS = 114 + INLINE = 115 + INPUT = 116 + INSENSITIVE = 117 + INSERT = 118 + INSTEAD = 119 + INVOKER = 120 + ISOLATION = 121 + KEY = 122 + LABEL = 123 + LANGUAGE = 124 + LARGE = 125 + LAST = 126 + LEAKPROOF = 127 + LEVEL = 128 + LISTEN = 129 + LOAD = 130 + LOCAL = 131 + LOCATION = 132 + LOCK = 133 + LOCKED = 134 + LOGGED = 135 + MAPPING = 136 + MATCH = 137 + MATERIALIZED = 138 + MAXVALUE = 139 + METHOD = 140 + MINUTE = 141 + MINVALUE = 142 + MODE = 143 + MONTH = 144 + MOVE = 145 + NAME = 146 + NAMES = 147 + NEW = 148 + NEXT = 149 + NO = 150 + NOTHING = 151 + NOTIFY = 152 + NOWAIT = 153 + NULLS = 154 + OBJECT = 155 + OF = 156 + OFF = 157 + OIDS = 158 + OLD = 159 + OPERATOR = 160 + OPTION = 161 + OPTIONS = 162 + ORDINALITY = 163 + OTHERS = 164 + OVER = 165 + OVERRIDING = 166 + OWNED = 167 + OWNER = 168 + PARALLEL = 169 + PARSER = 170 + PARTIAL = 171 + PARTITION = 172 + PASSING = 173 + PASSWORD = 174 + PLANS = 175 + POLICY = 176 + PRECEDING = 177 + PREPARE = 178 + PREPARED = 179 + PRESERVE = 180 + PRIOR = 181 + PRIVILEGES = 182 + PROCEDURAL = 183 + PROCEDURE = 184 + PROCEDURES = 185 + PROGRAM = 186 + PUBLICATION = 187 + QUOTE = 188 + RANGE = 189 + READ = 190 + REASSIGN = 191 + RECHECK = 192 + RECURSIVE = 193 + REF = 194 + REFERENCING = 195 + REFRESH = 196 + REINDEX = 197 + RELATIVE = 198 + RELEASE = 199 + RENAME = 200 + REPEATABLE = 201 + REPLACE = 202 + REPLICA = 203 + RESET = 204 + RESTART = 205 + RESTRICT = 206 + RETURNS = 207 + REVOKE = 208 + ROLE = 209 + ROLLBACK = 210 + ROLLUP = 211 + ROUTINE = 212 + ROUTINES = 213 + ROWS = 214 + RULE = 215 + SAVEPOINT = 216 + SCHEMA = 217 + SCHEMAS = 218 + SCROLL = 219 + SEARCH = 220 + SECOND = 221 + SECURITY = 222 + SEQUENCE = 223 + SEQUENCES = 224 + SERIALIZABLE = 225 + SERVER = 226 + SESSION = 227 + SET = 228 + SETS = 229 + SHARE = 230 + SHOW = 231 + SIMPLE = 232 + SKIP_ = 233 + SNAPSHOT = 234 + SQL = 235 + STABLE = 236 + STANDALONE = 237 + START = 238 + STATEMENT = 239 + STATISTICS = 240 + STDIN = 241 + STDOUT = 242 + STORAGE = 243 + STORED = 244 + STRICT = 245 + STRIP = 246 + SUBSCRIPTION = 247 + SUPPORT = 248 + SYSID = 249 + SYSTEM = 250 + TABLES = 251 + TABLESPACE = 252 + TEMP = 253 + TEMPLATE = 254 + TEMPORARY = 255 + TEXT = 256 + TIES = 257 + TRANSACTION = 258 + TRANSFORM = 259 + TRIGGER = 260 + TRUNCATE = 261 + TRUSTED = 262 + TYPE = 263 + TYPES = 264 + UNBOUNDED = 265 + UNCOMMITTED = 266 + UNENCRYPTED = 267 + UNKNOWN = 268 + UNLISTEN = 269 + UNLOGGED = 270 + UNTIL = 271 + UPDATE = 272 + VACUUM = 273 + VALID = 274 + VALIDATE = 275 + VALIDATOR = 276 + VALUE = 277 + VARYING = 278 + VERSION = 279 + VIEW = 280 + VIEWS = 281 + VOLATILE = 282 + WHITESPACE = 283 + WITHIN = 284 + WITHOUT = 285 + WORK = 286 + WRAPPER = 287 + WRITE = 288 + XML = 289 + YEAR = 290 + YES = 291 + ZONE = 292 + BETWEEN = 293 + BIGINT = 294 + BIT = 295 + BOOLEAN = 296 + CHAR = 297 + CHARACTER = 298 + COALESCE = 299 + DEC = 300 + DECIMAL = 301 + EXISTS = 302 + EXTRACT = 303 + FLOAT = 304 + GREATEST = 305 + GROUPING = 306 + INOUT = 307 + INT = 308 + INTEGER = 309 + INTERVAL = 310 + LEAST = 311 + NATIONAL = 312 + NCHAR = 313 + NONE = 314 + NULLIF = 315 + NUMERIC = 316 + OUT = 317 + OVERLAY = 318 + POSITION = 319 + PRECISION = 320 + REAL = 321 + ROW = 322 + SETOF = 323 + SMALLINT = 324 + SUBSTRING = 325 + TIME = 326 + TIMESTAMP = 327 + TREAT = 328 + TRIM = 329 + VALUES = 330 + VARCHAR = 331 + XMLATTRIBUTES = 332 + XMLCONCAT = 333 + XMLELEMENT = 334 + XMLEXISTS = 335 + XMLFOREST = 336 + XMLNAMESPACES = 337 + XMLPARSE = 338 + XMLPI = 339 + XMLROOT = 340 + XMLSERIALIZE = 341 + XMLTABLE = 342 + AUTHORIZATION = 343 + BINARY = 344 + COLLATION = 345 + CONCURRENTLY = 346 + CROSS = 347 + CURRENT_SCHEMA = 348 + FREEZE = 349 + FULL = 350 + ILIKE = 351 + INNER = 352 + IS = 353 + ISNULL = 354 + JOIN = 355 + LEFT = 356 + LIKE = 357 + NATURAL = 358 + NOTNULL = 359 + OUTER = 360 + OVERLAPS = 361 + RIGHT = 362 + SIMILAR = 363 + TABLESAMPLE = 364 + VERBOSE = 365 + ALL = 366 + ANALYSE = 367 + ANALYZE = 368 + AND = 369 + ANY = 370 + ARRAY = 371 + AS = 372 + ASC = 373 + ASYMMETRIC = 374 + BOTH = 375 + CASE = 376 + CAST = 377 + CHECK = 378 + COLLATE = 379 + COLUMN = 380 + CONSTRAINT = 381 + CREATE = 382 + CURRENT_CATALOG = 383 + CURRENT_DATE = 384 + CURRENT_ROLE = 385 + CURRENT_TIME = 386 + CURRENT_TIMESTAMP = 387 + CURRENT_USER = 388 + DEFAULT = 389 + DEFERRABLE = 390 + DESC = 391 + DISTINCT = 392 + DO = 393 + ELSE = 394 + END = 395 + EXCEPT = 396 + FALSE = 397 + FETCH = 398 + FOR = 399 + FOREIGN = 400 + FROM = 401 + GRANT = 402 + GROUP = 403 + HAVING = 404 + IN = 405 + INITIALLY = 406 + INTERSECT = 407 + INTO = 408 + LATERAL = 409 + LEADING = 410 + LIMIT = 411 + LOCALTIME = 412 + LOCALTIMESTAMP = 413 + NOT = 414 + NULL = 415 + OFFSET = 416 + ON = 417 + ONLY = 418 + OR = 419 + ORDER = 420 + PLACING = 421 + PRIMARY = 422 + REFERENCES = 423 + RETURNING = 424 + SELECT = 425 + SESSION_USER = 426 + SOME = 427 + SYMMETRIC = 428 + TABLE = 429 + THEN = 430 + TO = 431 + TRAILING = 432 + TRUE = 433 + UNION = 434 + UNIQUE = 435 + USER = 436 + USING = 437 + VARIADIC = 438 + WHEN = 439 + WHERE = 440 + WINDOW = 441 + WITH = 442 + ALIGNMENT = 443 + BASETYPE = 444 + BUFFERS = 445 + BYPASSRLS = 446 + CANONICAL = 447 + CATEGORY = 448 + COLLATABLE = 449 + COMBINEFUNC = 450 + COMMUTATOR = 451 + CONNECT = 452 + COSTS = 453 + CREATEDB = 454 + CREATEROLE = 455 + DESERIALFUNC = 456 + DETERMINISTIC = 457 + DISABLE_PAGE_SKIPPING = 458 + ELEMENT = 459 + EXTENDED = 460 + FINALFUNC = 461 + FINALFUNC_EXTRA = 462 + FINALFUNC_MODIFY = 463 + FORCE_NOT_NULL = 464 + FORCE_NULL = 465 + FORCE_QUOTE = 466 + FORMAT = 467 + GETTOKEN = 468 + HASH = 469 + HASHES = 470 + HEADLINE = 471 + HYPOTHETICAL = 472 + INDEX_CLEANUP = 473 + INIT = 474 + INITCOND = 475 + INTERNALLENGTH = 476 + JSON = 477 + LC_COLLATE = 478 + LC_CTYPE = 479 + LEFTARG = 480 + LEXIZE = 481 + LEXTYPES = 482 + LIST = 483 + LOCALE = 484 + LOGIN = 485 + MAIN = 486 + MERGES = 487 + MFINALFUNC = 488 + MFINALFUNC_EXTRA = 489 + MFINALFUNC_MODIFY = 490 + MINITCOND = 491 + MINVFUNC = 492 + MODULUS = 493 + MSFUNC = 494 + MSSPACE = 495 + MSTYPE = 496 + NEGATOR = 497 + NOBYPASSRLS = 498 + NOCREATEDB = 499 + NOCREATEROLE = 500 + NOINHERIT = 501 + NOLOGIN = 502 + NOREPLICATION = 503 + NOSUPERUSER = 504 + OUTPUT = 505 + PASSEDBYVALUE = 506 + PATH = 507 + PERMISSIVE = 508 + PLAIN = 509 + PREFERRED = 510 + PROVIDER = 511 + READ_ONLY = 512 + READ_WRITE = 513 + RECEIVE = 514 + REMAINDER = 515 + REPLICATION = 516 + RESTRICTED = 517 + RESTRICTIVE = 518 + RIGHTARG = 519 + SAFE = 520 + SEND = 521 + SERIALFUNC = 522 + SETTINGS = 523 + SFUNC = 524 + SHAREABLE = 525 + SKIP_LOCKED = 526 + SORTOP = 527 + SSPACE = 528 + STYPE = 529 + SUBTYPE_DIFF = 530 + SUBTYPE_OPCLASS = 531 + SUBTYPE = 532 + SUMMARY = 533 + SUPERUSER = 534 + TIMING = 535 + TYPMOD_IN = 536 + TYPMOD_OUT = 537 + UNSAFE = 538 + USAGE = 539 + VARIABLE = 540 + YAML = 541 + ALIAS = 542 + ASSERT = 543 + CONSTANT = 544 + DATATYPE = 545 + DEBUG = 546 + DETAIL = 547 + DIAGNOSTICS = 548 + ELSEIF = 549 + ELSIF = 550 + ERRCODE = 551 + EXIT = 552 + EXCEPTION = 553 + FOREACH = 554 + GET = 555 + HINT = 556 + INFO = 557 + LOG = 558 + LOOP = 559 + MESSAGE = 560 + NOTICE = 561 + OPEN = 562 + PERFORM = 563 + QUERY = 564 + RAISE = 565 + RECORD = 566 + RETURN = 567 + REVERSE = 568 + ROWTYPE = 569 + SLICE = 570 + SQLSTATE = 571 + STACKED = 572 + WARNING = 573 + WHILE = 574 + CAST_EXPRESSION = 575 + EQUAL = 576 + COLON = 577 + SEMI_COLON = 578 + COMMA = 579 + NOT_EQUAL = 580 + LTH = 581 + LEQ = 582 + GTH = 583 + GEQ = 584 + LEFT_PAREN = 585 + RIGHT_PAREN = 586 + PLUS = 587 + MINUS = 588 + MULTIPLY = 589 + DIVIDE = 590 + MODULAR = 591 + EXP = 592 + DOT = 593 + QUOTE_CHAR = 594 + DOUBLE_QUOTE = 595 + DOLLAR = 596 + LEFT_BRACKET = 597 + RIGHT_BRACKET = 598 + EQUAL_GTH = 599 + COLON_EQUAL = 600 + LESS_LESS = 601 + GREATER_GREATER = 602 + DOUBLE_DOT = 603 + HASH_SIGN = 604 + BlockComment = 605 + LineComment = 606 + OP_CHARS = 607 + NUMBER_LITERAL = 608 + REAL_NUMBER = 609 + DOLLAR_NUMBER = 610 + Identifier = 611 + QuotedIdentifier = 612 + Character_String_Literal = 613 + BeginDollarStringConstant = 614 + Space = 615 + White_Space = 616 + New_Line = 617 + Tab = 618 + BOM = 619 + BAD = 620 + Text_between_Dollar = 621 + EndDollarStringConstant = 622 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE", "DollarQuotedStringMode" ] + + literalNames = [ "", + "'='", "':'", "';'", "','", "'<'", "'<='", "'>'", "'>='", "'('", + "')'", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'.'", "'''", + "'\"'", "'$'", "'['", "']'", "'=>'", "':='", "'<<'", "'>>'", + "'..'", "'#'", "' '", "'\u0009'", "'\uFEFF'" ] + + symbolicNames = [ "", + "ABORT", "ABSOLUTE", "ACCESS", "ACTION", "ADD", "ADMIN", "AFTER", + "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", + "AT", "ATTACH", "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN", + "BY", "CACHE", "CALL", "CALLED", "CASCADE", "CASCADED", "CATALOG", + "CHAIN", "CHARACTERISTICS", "CHECKPOINT", "CLASS", "CLOSE", + "CLUSTER", "COLUMNS", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", + "CONFIGURATION", "CONFLICT", "CONNECTION", "CONSTRAINTS", "CONTENT", + "CONTINUE", "CONVERSION", "COPY", "COST", "CSV", "CUBE", "CURRENT", + "CURSOR", "CYCLE", "DATA", "DATABASE", "DAY", "DEALLOCATE", + "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE", "DELIMITER", + "DELIMITERS", "DEPENDS", "DETACH", "DICTIONARY", "DISABLE", + "DISCARD", "DOCUMENT", "DOMAIN", "DOUBLE", "DROP", "EACH", "ENABLE", + "ENCODING", "ENCRYPTED", "ENUM", "ESCAPE", "EVENT", "EXCLUDE", + "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXTENSION", + "EXTERNAL", "FAMILY", "FILTER", "FIRST", "FOLLOWING", "FORCE", + "FORWARD", "FUNCTION", "FUNCTIONS", "GENERATED", "GLOBAL", "GRANTED", + "GROUPS", "HANDLER", "HEADER", "HOLD", "HOUR", "IDENTITY", "IF", + "IMMEDIATE", "IMMUTABLE", "IMPLICIT", "IMPORT", "INCLUDE", "INCLUDING", + "INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS", "INLINE", + "INPUT", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", "ISOLATION", + "KEY", "LABEL", "LANGUAGE", "LARGE", "LAST", "LEAKPROOF", "LEVEL", + "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK", "LOCKED", "LOGGED", + "MAPPING", "MATCH", "MATERIALIZED", "MAXVALUE", "METHOD", "MINUTE", + "MINVALUE", "MODE", "MONTH", "MOVE", "NAME", "NAMES", "NEW", + "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", "NULLS", "OBJECT", + "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", "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", + "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", "ROLE", + "ROLLBACK", "ROLLUP", "ROUTINE", "ROUTINES", "ROWS", "RULE", + "SAVEPOINT", "SCHEMA", "SCHEMAS", "SCROLL", "SEARCH", "SECOND", + "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER", + "SESSION", "SET", "SETS", "SHARE", "SHOW", "SIMPLE", "SKIP_", + "SNAPSHOT", "SQL", "STABLE", "STANDALONE", "START", "STATEMENT", + "STATISTICS", "STDIN", "STDOUT", "STORAGE", "STORED", "STRICT", + "STRIP", "SUBSCRIPTION", "SUPPORT", "SYSID", "SYSTEM", "TABLES", + "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TEXT", "TIES", + "TRANSACTION", "TRANSFORM", "TRIGGER", "TRUNCATE", "TRUSTED", + "TYPE", "TYPES", "UNBOUNDED", "UNCOMMITTED", "UNENCRYPTED", + "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", "VACUUM", + "VALID", "VALIDATE", "VALIDATOR", "VALUE", "VARYING", "VERSION", + "VIEW", "VIEWS", "VOLATILE", "WHITESPACE", "WITHIN", "WITHOUT", + "WORK", "WRAPPER", "WRITE", "XML", "YEAR", "YES", "ZONE", "BETWEEN", + "BIGINT", "BIT", "BOOLEAN", "CHAR", "CHARACTER", "COALESCE", + "DEC", "DECIMAL", "EXISTS", "EXTRACT", "FLOAT", "GREATEST", + "GROUPING", "INOUT", "INT", "INTEGER", "INTERVAL", "LEAST", + "NATIONAL", "NCHAR", "NONE", "NULLIF", "NUMERIC", "OUT", "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", "AUTHORIZATION", "BINARY", "COLLATION", + "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", + "ILIKE", "INNER", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", + "NOTNULL", "OUTER", "OVERLAPS", "RIGHT", "SIMILAR", "TABLESAMPLE", + "VERBOSE", "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", "EXCEPT", "FALSE", "FETCH", "FOR", "FOREIGN", + "FROM", "GRANT", "GROUP", "HAVING", "IN", "INITIALLY", "INTERSECT", + "INTO", "LATERAL", "LEADING", "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", + "NOT", "NULL", "OFFSET", "ON", "ONLY", "OR", "ORDER", "PLACING", + "PRIMARY", "REFERENCES", "RETURNING", "SELECT", "SESSION_USER", + "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", "TRAILING", "TRUE", + "UNION", "UNIQUE", "USER", "USING", "VARIADIC", "WHEN", "WHERE", + "WINDOW", "WITH", "ALIGNMENT", "BASETYPE", "BUFFERS", "BYPASSRLS", + "CANONICAL", "CATEGORY", "COLLATABLE", "COMBINEFUNC", "COMMUTATOR", + "CONNECT", "COSTS", "CREATEDB", "CREATEROLE", "DESERIALFUNC", + "DETERMINISTIC", "DISABLE_PAGE_SKIPPING", "ELEMENT", "EXTENDED", + "FINALFUNC", "FINALFUNC_EXTRA", "FINALFUNC_MODIFY", "FORCE_NOT_NULL", + "FORCE_NULL", "FORCE_QUOTE", "FORMAT", "GETTOKEN", "HASH", "HASHES", + "HEADLINE", "HYPOTHETICAL", "INDEX_CLEANUP", "INIT", "INITCOND", + "INTERNALLENGTH", "JSON", "LC_COLLATE", "LC_CTYPE", "LEFTARG", + "LEXIZE", "LEXTYPES", "LIST", "LOCALE", "LOGIN", "MAIN", "MERGES", + "MFINALFUNC", "MFINALFUNC_EXTRA", "MFINALFUNC_MODIFY", "MINITCOND", + "MINVFUNC", "MODULUS", "MSFUNC", "MSSPACE", "MSTYPE", "NEGATOR", + "NOBYPASSRLS", "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", "NOLOGIN", + "NOREPLICATION", "NOSUPERUSER", "OUTPUT", "PASSEDBYVALUE", "PATH", + "PERMISSIVE", "PLAIN", "PREFERRED", "PROVIDER", "READ_ONLY", + "READ_WRITE", "RECEIVE", "REMAINDER", "REPLICATION", "RESTRICTED", + "RESTRICTIVE", "RIGHTARG", "SAFE", "SEND", "SERIALFUNC", "SETTINGS", + "SFUNC", "SHAREABLE", "SKIP_LOCKED", "SORTOP", "SSPACE", "STYPE", + "SUBTYPE_DIFF", "SUBTYPE_OPCLASS", "SUBTYPE", "SUMMARY", "SUPERUSER", + "TIMING", "TYPMOD_IN", "TYPMOD_OUT", "UNSAFE", "USAGE", "VARIABLE", + "YAML", "ALIAS", "ASSERT", "CONSTANT", "DATATYPE", "DEBUG", + "DETAIL", "DIAGNOSTICS", "ELSEIF", "ELSIF", "ERRCODE", "EXIT", + "EXCEPTION", "FOREACH", "GET", "HINT", "INFO", "LOG", "LOOP", + "MESSAGE", "NOTICE", "OPEN", "PERFORM", "QUERY", "RAISE", "RECORD", + "RETURN", "REVERSE", "ROWTYPE", "SLICE", "SQLSTATE", "STACKED", + "WARNING", "WHILE", "CAST_EXPRESSION", "EQUAL", "COLON", "SEMI_COLON", + "COMMA", "NOT_EQUAL", "LTH", "LEQ", "GTH", "GEQ", "LEFT_PAREN", + "RIGHT_PAREN", "PLUS", "MINUS", "MULTIPLY", "DIVIDE", "MODULAR", + "EXP", "DOT", "QUOTE_CHAR", "DOUBLE_QUOTE", "DOLLAR", "LEFT_BRACKET", + "RIGHT_BRACKET", "EQUAL_GTH", "COLON_EQUAL", "LESS_LESS", "GREATER_GREATER", + "DOUBLE_DOT", "HASH_SIGN", "BlockComment", "LineComment", "OP_CHARS", + "NUMBER_LITERAL", "REAL_NUMBER", "DOLLAR_NUMBER", "Identifier", + "QuotedIdentifier", "Character_String_Literal", "BeginDollarStringConstant", + "Space", "White_Space", "New_Line", "Tab", "BOM", "BAD", "Text_between_Dollar", + "EndDollarStringConstant" ] + + ruleNames = [ "ABORT", "ABSOLUTE", "ACCESS", "ACTION", "ADD", "ADMIN", + "AFTER", "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASSERTION", + "ASSIGNMENT", "AT", "ATTACH", "ATTRIBUTE", "BACKWARD", + "BEFORE", "BEGIN", "BY", "CACHE", "CALL", "CALLED", "CASCADE", + "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", + "CLASS", "CLOSE", "CLUSTER", "COLUMNS", "COMMENT", "COMMENTS", + "COMMIT", "COMMITTED", "CONFIGURATION", "CONFLICT", "CONNECTION", + "CONSTRAINTS", "CONTENT", "CONTINUE", "CONVERSION", "COPY", + "COST", "CSV", "CUBE", "CURRENT", "CURSOR", "CYCLE", "DATA", + "DATABASE", "DAY", "DEALLOCATE", "DECLARE", "DEFAULTS", + "DEFERRED", "DEFINER", "DELETE", "DELIMITER", "DELIMITERS", + "DEPENDS", "DETACH", "DICTIONARY", "DISABLE", "DISCARD", + "DOCUMENT", "DOMAIN", "DOUBLE", "DROP", "EACH", "ENABLE", + "ENCODING", "ENCRYPTED", "ENUM", "ESCAPE", "EVENT", "EXCLUDE", + "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXTENSION", + "EXTERNAL", "FAMILY", "FILTER", "FIRST", "FOLLOWING", + "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GENERATED", + "GLOBAL", "GRANTED", "GROUPS", "HANDLER", "HEADER", "HOLD", + "HOUR", "IDENTITY", "IF", "IMMEDIATE", "IMMUTABLE", "IMPLICIT", + "IMPORT", "INCLUDE", "INCLUDING", "INCREMENT", "INDEX", + "INDEXES", "INHERIT", "INHERITS", "INLINE", "INPUT", "INSENSITIVE", + "INSERT", "INSTEAD", "INVOKER", "ISOLATION", "KEY", "LABEL", + "LANGUAGE", "LARGE", "LAST", "LEAKPROOF", "LEVEL", "LISTEN", + "LOAD", "LOCAL", "LOCATION", "LOCK", "LOCKED", "LOGGED", + "MAPPING", "MATCH", "MATERIALIZED", "MAXVALUE", "METHOD", + "MINUTE", "MINVALUE", "MODE", "MONTH", "MOVE", "NAME", + "NAMES", "NEW", "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", + "NULLS", "OBJECT", "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", + "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", + "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", "ROLE", + "ROLLBACK", "ROLLUP", "ROUTINE", "ROUTINES", "ROWS", "RULE", + "SAVEPOINT", "SCHEMA", "SCHEMAS", "SCROLL", "SEARCH", + "SECOND", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", + "SERVER", "SESSION", "SET", "SETS", "SHARE", "SHOW", "SIMPLE", + "SKIP_", "SNAPSHOT", "SQL", "STABLE", "STANDALONE", "START", + "STATEMENT", "STATISTICS", "STDIN", "STDOUT", "STORAGE", + "STORED", "STRICT", "STRIP", "SUBSCRIPTION", "SUPPORT", + "SYSID", "SYSTEM", "TABLES", "TABLESPACE", "TEMP", "TEMPLATE", + "TEMPORARY", "TEXT", "TIES", "TRANSACTION", "TRANSFORM", + "TRIGGER", "TRUNCATE", "TRUSTED", "TYPE", "TYPES", "UNBOUNDED", + "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", + "UNTIL", "UPDATE", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", + "VALUE", "VARYING", "VERSION", "VIEW", "VIEWS", "VOLATILE", + "WHITESPACE", "WITHIN", "WITHOUT", "WORK", "WRAPPER", + "WRITE", "XML", "YEAR", "YES", "ZONE", "BETWEEN", "BIGINT", + "BIT", "BOOLEAN", "CHAR", "CHARACTER", "COALESCE", "DEC", + "DECIMAL", "EXISTS", "EXTRACT", "FLOAT", "GREATEST", "GROUPING", + "INOUT", "INT", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", "OUT", "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", "AUTHORIZATION", + "BINARY", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", + "FREEZE", "FULL", "ILIKE", "INNER", "IS", "ISNULL", "JOIN", + "LEFT", "LIKE", "NATURAL", "NOTNULL", "OUTER", "OVERLAPS", + "RIGHT", "SIMILAR", "TABLESAMPLE", "VERBOSE", "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", "EXCEPT", "FALSE", "FETCH", "FOR", "FOREIGN", "FROM", + "GRANT", "GROUP", "HAVING", "IN", "INITIALLY", "INTERSECT", + "INTO", "LATERAL", "LEADING", "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", + "NOT", "NULL", "OFFSET", "ON", "ONLY", "OR", "ORDER", + "PLACING", "PRIMARY", "REFERENCES", "RETURNING", "SELECT", + "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", "THEN", + "TO", "TRAILING", "TRUE", "UNION", "UNIQUE", "USER", "USING", + "VARIADIC", "WHEN", "WHERE", "WINDOW", "WITH", "ALIGNMENT", + "BASETYPE", "BUFFERS", "BYPASSRLS", "CANONICAL", "CATEGORY", + "COLLATABLE", "COMBINEFUNC", "COMMUTATOR", "CONNECT", + "COSTS", "CREATEDB", "CREATEROLE", "DESERIALFUNC", "DETERMINISTIC", + "DISABLE_PAGE_SKIPPING", "ELEMENT", "EXTENDED", "FINALFUNC", + "FINALFUNC_EXTRA", "FINALFUNC_MODIFY", "FORCE_NOT_NULL", + "FORCE_NULL", "FORCE_QUOTE", "FORMAT", "GETTOKEN", "HASH", + "HASHES", "HEADLINE", "HYPOTHETICAL", "INDEX_CLEANUP", + "INIT", "INITCOND", "INTERNALLENGTH", "JSON", "LC_COLLATE", + "LC_CTYPE", "LEFTARG", "LEXIZE", "LEXTYPES", "LIST", "LOCALE", + "LOGIN", "MAIN", "MERGES", "MFINALFUNC", "MFINALFUNC_EXTRA", + "MFINALFUNC_MODIFY", "MINITCOND", "MINVFUNC", "MODULUS", + "MSFUNC", "MSSPACE", "MSTYPE", "NEGATOR", "NOBYPASSRLS", + "NOCREATEDB", "NOCREATEROLE", "NOINHERIT", "NOLOGIN", + "NOREPLICATION", "NOSUPERUSER", "OUTPUT", "PASSEDBYVALUE", + "PATH", "PERMISSIVE", "PLAIN", "PREFERRED", "PROVIDER", + "READ_ONLY", "READ_WRITE", "RECEIVE", "REMAINDER", "REPLICATION", + "RESTRICTED", "RESTRICTIVE", "RIGHTARG", "SAFE", "SEND", + "SERIALFUNC", "SETTINGS", "SFUNC", "SHAREABLE", "SKIP_LOCKED", + "SORTOP", "SSPACE", "STYPE", "SUBTYPE_DIFF", "SUBTYPE_OPCLASS", + "SUBTYPE", "SUMMARY", "SUPERUSER", "TIMING", "TYPMOD_IN", + "TYPMOD_OUT", "UNSAFE", "USAGE", "VARIABLE", "YAML", "ALIAS", + "ASSERT", "CONSTANT", "DATATYPE", "DEBUG", "DETAIL", "DIAGNOSTICS", + "ELSEIF", "ELSIF", "ERRCODE", "EXIT", "EXCEPTION", "FOREACH", + "GET", "HINT", "INFO", "LOG", "LOOP", "MESSAGE", "NOTICE", + "OPEN", "PERFORM", "QUERY", "RAISE", "RECORD", "RETURN", + "REVERSE", "ROWTYPE", "SLICE", "SQLSTATE", "STACKED", + "WARNING", "WHILE", "UNDERLINE", "CAST_EXPRESSION", "EQUAL", + "COLON", "SEMI_COLON", "COMMA", "NOT_EQUAL", "LTH", "LEQ", + "GTH", "GEQ", "LEFT_PAREN", "RIGHT_PAREN", "PLUS", "MINUS", + "MULTIPLY", "DIVIDE", "MODULAR", "EXP", "DOT", "QUOTE_CHAR", + "DOUBLE_QUOTE", "DOLLAR", "LEFT_BRACKET", "RIGHT_BRACKET", + "EQUAL_GTH", "COLON_EQUAL", "LESS_LESS", "GREATER_GREATER", + "DOUBLE_DOT", "HASH_SIGN", "BlockComment", "LineComment", + "OP_CHARS", "OperatorBasic", "OperatorBasicEnd", "OperatorSpecial", + "NUMBER_LITERAL", "Digit", "REAL_NUMBER", "DOLLAR_NUMBER", + "Identifier", "IdentifierStartChar", "IdentifierChar", + "StrictIdentifierChar", "QuotedIdentifier", "UnterminatedQuotedIdentifier", + "Control_Characters", "Extended_Control_Characters", "Character_String_Literal", + "Single_String", "String_Joiner", "EXPONENT", "BeginDollarStringConstant", + "Tag", "Space", "White_Space", "New_Line", "Tab", "BOM", + "BAD", "Text_between_Dollar", "EndDollarStringConstant" ] + + grammarFileName = "PLpgSQLLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + + def action(self, localctx:RuleContext, ruleIndex:int, actionIndex:int): + if self._actions is None: + actions = dict() + actions[615] = self.Identifier_action + actions[619] = self.QuotedIdentifier_action + actions[627] = self.BeginDollarStringConstant_action + actions[636] = self.EndDollarStringConstant_action + self._actions = actions + action = self._actions.get(ruleIndex, None) + if action is not None: + action(localctx, actionIndex) + else: + raise Exception("No registered action for:" + str(ruleIndex)) + + + def Identifier_action(self, localctx:RuleContext , actionIndex:int): + if actionIndex == 0: + print("Identifier_action") + + def QuotedIdentifier_action(self, localctx:RuleContext , actionIndex:int): + if actionIndex == 1: + print("QuotedIdentifier_action") + + + def BeginDollarStringConstant_action(self, localctx:RuleContext , actionIndex:int): + if actionIndex == 2: + print("BeginDollarStringConstant_action") + + + def EndDollarStringConstant_action(self, localctx:RuleContext , actionIndex:int): + if actionIndex == 3: + print("EndDollarStringConstant_action") + + + def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): + if self._predicates is None: + preds = dict() + preds[608] = self.OperatorBasic_sempred + preds[613] = self.REAL_NUMBER_sempred + preds[616] = self.IdentifierStartChar_sempred + preds[636] = self.EndDollarStringConstant_sempred + self._predicates = preds + pred = self._predicates.get(ruleIndex, None) + if pred is not None: + return pred(localctx, predIndex) + else: + raise Exception("No registered predicate for:" + str(ruleIndex)) + + def OperatorBasic_sempred(self, localctx:RuleContext, predIndex:int): + if predIndex == 0: + return + + + if predIndex == 1: + return + + + def REAL_NUMBER_sempred(self, localctx:RuleContext, predIndex:int): + if predIndex == 2: + return + + + def IdentifierStartChar_sempred(self, localctx:RuleContext, predIndex:int): + if predIndex == 3: + return + + + if predIndex == 4: + return + + + def EndDollarStringConstant_sempred(self, localctx:RuleContext, predIndex:int): + if predIndex == 5: + return + + + diff --git a/sql_to_code/parsers/generated/PLpgSQLLexer.tokens b/sql_to_code/parsers/generated/PLpgSQLLexer.tokens new file mode 100644 index 0000000..c2a813a --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLLexer.tokens @@ -0,0 +1,653 @@ +ABORT=1 +ABSOLUTE=2 +ACCESS=3 +ACTION=4 +ADD=5 +ADMIN=6 +AFTER=7 +AGGREGATE=8 +ALSO=9 +ALTER=10 +ALWAYS=11 +ASSERTION=12 +ASSIGNMENT=13 +AT=14 +ATTACH=15 +ATTRIBUTE=16 +BACKWARD=17 +BEFORE=18 +BEGIN=19 +BY=20 +CACHE=21 +CALL=22 +CALLED=23 +CASCADE=24 +CASCADED=25 +CATALOG=26 +CHAIN=27 +CHARACTERISTICS=28 +CHECKPOINT=29 +CLASS=30 +CLOSE=31 +CLUSTER=32 +COLUMNS=33 +COMMENT=34 +COMMENTS=35 +COMMIT=36 +COMMITTED=37 +CONFIGURATION=38 +CONFLICT=39 +CONNECTION=40 +CONSTRAINTS=41 +CONTENT=42 +CONTINUE=43 +CONVERSION=44 +COPY=45 +COST=46 +CSV=47 +CUBE=48 +CURRENT=49 +CURSOR=50 +CYCLE=51 +DATA=52 +DATABASE=53 +DAY=54 +DEALLOCATE=55 +DECLARE=56 +DEFAULTS=57 +DEFERRED=58 +DEFINER=59 +DELETE=60 +DELIMITER=61 +DELIMITERS=62 +DEPENDS=63 +DETACH=64 +DICTIONARY=65 +DISABLE=66 +DISCARD=67 +DOCUMENT=68 +DOMAIN=69 +DOUBLE=70 +DROP=71 +EACH=72 +ENABLE=73 +ENCODING=74 +ENCRYPTED=75 +ENUM=76 +ESCAPE=77 +EVENT=78 +EXCLUDE=79 +EXCLUDING=80 +EXCLUSIVE=81 +EXECUTE=82 +EXPLAIN=83 +EXTENSION=84 +EXTERNAL=85 +FAMILY=86 +FILTER=87 +FIRST=88 +FOLLOWING=89 +FORCE=90 +FORWARD=91 +FUNCTION=92 +FUNCTIONS=93 +GENERATED=94 +GLOBAL=95 +GRANTED=96 +GROUPS=97 +HANDLER=98 +HEADER=99 +HOLD=100 +HOUR=101 +IDENTITY=102 +IF=103 +IMMEDIATE=104 +IMMUTABLE=105 +IMPLICIT=106 +IMPORT=107 +INCLUDE=108 +INCLUDING=109 +INCREMENT=110 +INDEX=111 +INDEXES=112 +INHERIT=113 +INHERITS=114 +INLINE=115 +INPUT=116 +INSENSITIVE=117 +INSERT=118 +INSTEAD=119 +INVOKER=120 +ISOLATION=121 +KEY=122 +LABEL=123 +LANGUAGE=124 +LARGE=125 +LAST=126 +LEAKPROOF=127 +LEVEL=128 +LISTEN=129 +LOAD=130 +LOCAL=131 +LOCATION=132 +LOCK=133 +LOCKED=134 +LOGGED=135 +MAPPING=136 +MATCH=137 +MATERIALIZED=138 +MAXVALUE=139 +METHOD=140 +MINUTE=141 +MINVALUE=142 +MODE=143 +MONTH=144 +MOVE=145 +NAME=146 +NAMES=147 +NEW=148 +NEXT=149 +NO=150 +NOTHING=151 +NOTIFY=152 +NOWAIT=153 +NULLS=154 +OBJECT=155 +OF=156 +OFF=157 +OIDS=158 +OLD=159 +OPERATOR=160 +OPTION=161 +OPTIONS=162 +ORDINALITY=163 +OTHERS=164 +OVER=165 +OVERRIDING=166 +OWNED=167 +OWNER=168 +PARALLEL=169 +PARSER=170 +PARTIAL=171 +PARTITION=172 +PASSING=173 +PASSWORD=174 +PLANS=175 +POLICY=176 +PRECEDING=177 +PREPARE=178 +PREPARED=179 +PRESERVE=180 +PRIOR=181 +PRIVILEGES=182 +PROCEDURAL=183 +PROCEDURE=184 +PROCEDURES=185 +PROGRAM=186 +PUBLICATION=187 +QUOTE=188 +RANGE=189 +READ=190 +REASSIGN=191 +RECHECK=192 +RECURSIVE=193 +REF=194 +REFERENCING=195 +REFRESH=196 +REINDEX=197 +RELATIVE=198 +RELEASE=199 +RENAME=200 +REPEATABLE=201 +REPLACE=202 +REPLICA=203 +RESET=204 +RESTART=205 +RESTRICT=206 +RETURNS=207 +REVOKE=208 +ROLE=209 +ROLLBACK=210 +ROLLUP=211 +ROUTINE=212 +ROUTINES=213 +ROWS=214 +RULE=215 +SAVEPOINT=216 +SCHEMA=217 +SCHEMAS=218 +SCROLL=219 +SEARCH=220 +SECOND=221 +SECURITY=222 +SEQUENCE=223 +SEQUENCES=224 +SERIALIZABLE=225 +SERVER=226 +SESSION=227 +SET=228 +SETS=229 +SHARE=230 +SHOW=231 +SIMPLE=232 +SKIP_=233 +SNAPSHOT=234 +SQL=235 +STABLE=236 +STANDALONE=237 +START=238 +STATEMENT=239 +STATISTICS=240 +STDIN=241 +STDOUT=242 +STORAGE=243 +STORED=244 +STRICT=245 +STRIP=246 +SUBSCRIPTION=247 +SUPPORT=248 +SYSID=249 +SYSTEM=250 +TABLES=251 +TABLESPACE=252 +TEMP=253 +TEMPLATE=254 +TEMPORARY=255 +TEXT=256 +TIES=257 +TRANSACTION=258 +TRANSFORM=259 +TRIGGER=260 +TRUNCATE=261 +TRUSTED=262 +TYPE=263 +TYPES=264 +UNBOUNDED=265 +UNCOMMITTED=266 +UNENCRYPTED=267 +UNKNOWN=268 +UNLISTEN=269 +UNLOGGED=270 +UNTIL=271 +UPDATE=272 +VACUUM=273 +VALID=274 +VALIDATE=275 +VALIDATOR=276 +VALUE=277 +VARYING=278 +VERSION=279 +VIEW=280 +VIEWS=281 +VOLATILE=282 +WHITESPACE=283 +WITHIN=284 +WITHOUT=285 +WORK=286 +WRAPPER=287 +WRITE=288 +XML=289 +YEAR=290 +YES=291 +ZONE=292 +BETWEEN=293 +BIGINT=294 +BIT=295 +BOOLEAN=296 +CHAR=297 +CHARACTER=298 +COALESCE=299 +DEC=300 +DECIMAL=301 +EXISTS=302 +EXTRACT=303 +FLOAT=304 +GREATEST=305 +GROUPING=306 +INOUT=307 +INT=308 +INTEGER=309 +INTERVAL=310 +LEAST=311 +NATIONAL=312 +NCHAR=313 +NONE=314 +NULLIF=315 +NUMERIC=316 +OUT=317 +OVERLAY=318 +POSITION=319 +PRECISION=320 +REAL=321 +ROW=322 +SETOF=323 +SMALLINT=324 +SUBSTRING=325 +TIME=326 +TIMESTAMP=327 +TREAT=328 +TRIM=329 +VALUES=330 +VARCHAR=331 +XMLATTRIBUTES=332 +XMLCONCAT=333 +XMLELEMENT=334 +XMLEXISTS=335 +XMLFOREST=336 +XMLNAMESPACES=337 +XMLPARSE=338 +XMLPI=339 +XMLROOT=340 +XMLSERIALIZE=341 +XMLTABLE=342 +AUTHORIZATION=343 +BINARY=344 +COLLATION=345 +CONCURRENTLY=346 +CROSS=347 +CURRENT_SCHEMA=348 +FREEZE=349 +FULL=350 +ILIKE=351 +INNER=352 +IS=353 +ISNULL=354 +JOIN=355 +LEFT=356 +LIKE=357 +NATURAL=358 +NOTNULL=359 +OUTER=360 +OVERLAPS=361 +RIGHT=362 +SIMILAR=363 +TABLESAMPLE=364 +VERBOSE=365 +ALL=366 +ANALYSE=367 +ANALYZE=368 +AND=369 +ANY=370 +ARRAY=371 +AS=372 +ASC=373 +ASYMMETRIC=374 +BOTH=375 +CASE=376 +CAST=377 +CHECK=378 +COLLATE=379 +COLUMN=380 +CONSTRAINT=381 +CREATE=382 +CURRENT_CATALOG=383 +CURRENT_DATE=384 +CURRENT_ROLE=385 +CURRENT_TIME=386 +CURRENT_TIMESTAMP=387 +CURRENT_USER=388 +DEFAULT=389 +DEFERRABLE=390 +DESC=391 +DISTINCT=392 +DO=393 +ELSE=394 +END=395 +EXCEPT=396 +FALSE=397 +FETCH=398 +FOR=399 +FOREIGN=400 +FROM=401 +GRANT=402 +GROUP=403 +HAVING=404 +IN=405 +INITIALLY=406 +INTERSECT=407 +INTO=408 +LATERAL=409 +LEADING=410 +LIMIT=411 +LOCALTIME=412 +LOCALTIMESTAMP=413 +NOT=414 +NULL=415 +OFFSET=416 +ON=417 +ONLY=418 +OR=419 +ORDER=420 +PLACING=421 +PRIMARY=422 +REFERENCES=423 +RETURNING=424 +SELECT=425 +SESSION_USER=426 +SOME=427 +SYMMETRIC=428 +TABLE=429 +THEN=430 +TO=431 +TRAILING=432 +TRUE=433 +UNION=434 +UNIQUE=435 +USER=436 +USING=437 +VARIADIC=438 +WHEN=439 +WHERE=440 +WINDOW=441 +WITH=442 +ALIGNMENT=443 +BASETYPE=444 +BUFFERS=445 +BYPASSRLS=446 +CANONICAL=447 +CATEGORY=448 +COLLATABLE=449 +COMBINEFUNC=450 +COMMUTATOR=451 +CONNECT=452 +COSTS=453 +CREATEDB=454 +CREATEROLE=455 +DESERIALFUNC=456 +DETERMINISTIC=457 +DISABLE_PAGE_SKIPPING=458 +ELEMENT=459 +EXTENDED=460 +FINALFUNC=461 +FINALFUNC_EXTRA=462 +FINALFUNC_MODIFY=463 +FORCE_NOT_NULL=464 +FORCE_NULL=465 +FORCE_QUOTE=466 +FORMAT=467 +GETTOKEN=468 +HASH=469 +HASHES=470 +HEADLINE=471 +HYPOTHETICAL=472 +INDEX_CLEANUP=473 +INIT=474 +INITCOND=475 +INTERNALLENGTH=476 +JSON=477 +LC_COLLATE=478 +LC_CTYPE=479 +LEFTARG=480 +LEXIZE=481 +LEXTYPES=482 +LIST=483 +LOCALE=484 +LOGIN=485 +MAIN=486 +MERGES=487 +MFINALFUNC=488 +MFINALFUNC_EXTRA=489 +MFINALFUNC_MODIFY=490 +MINITCOND=491 +MINVFUNC=492 +MODULUS=493 +MSFUNC=494 +MSSPACE=495 +MSTYPE=496 +NEGATOR=497 +NOBYPASSRLS=498 +NOCREATEDB=499 +NOCREATEROLE=500 +NOINHERIT=501 +NOLOGIN=502 +NOREPLICATION=503 +NOSUPERUSER=504 +OUTPUT=505 +PASSEDBYVALUE=506 +PATH=507 +PERMISSIVE=508 +PLAIN=509 +PREFERRED=510 +PROVIDER=511 +READ_ONLY=512 +READ_WRITE=513 +RECEIVE=514 +REMAINDER=515 +REPLICATION=516 +RESTRICTED=517 +RESTRICTIVE=518 +RIGHTARG=519 +SAFE=520 +SEND=521 +SERIALFUNC=522 +SETTINGS=523 +SFUNC=524 +SHAREABLE=525 +SKIP_LOCKED=526 +SORTOP=527 +SSPACE=528 +STYPE=529 +SUBTYPE_DIFF=530 +SUBTYPE_OPCLASS=531 +SUBTYPE=532 +SUMMARY=533 +SUPERUSER=534 +TIMING=535 +TYPMOD_IN=536 +TYPMOD_OUT=537 +UNSAFE=538 +USAGE=539 +VARIABLE=540 +YAML=541 +ALIAS=542 +ASSERT=543 +CONSTANT=544 +DATATYPE=545 +DEBUG=546 +DETAIL=547 +DIAGNOSTICS=548 +ELSEIF=549 +ELSIF=550 +ERRCODE=551 +EXIT=552 +EXCEPTION=553 +FOREACH=554 +GET=555 +HINT=556 +INFO=557 +LOG=558 +LOOP=559 +MESSAGE=560 +NOTICE=561 +OPEN=562 +PERFORM=563 +QUERY=564 +RAISE=565 +RECORD=566 +RETURN=567 +REVERSE=568 +ROWTYPE=569 +SLICE=570 +SQLSTATE=571 +STACKED=572 +WARNING=573 +WHILE=574 +CAST_EXPRESSION=575 +EQUAL=576 +COLON=577 +SEMI_COLON=578 +COMMA=579 +NOT_EQUAL=580 +LTH=581 +LEQ=582 +GTH=583 +GEQ=584 +LEFT_PAREN=585 +RIGHT_PAREN=586 +PLUS=587 +MINUS=588 +MULTIPLY=589 +DIVIDE=590 +MODULAR=591 +EXP=592 +DOT=593 +QUOTE_CHAR=594 +DOUBLE_QUOTE=595 +DOLLAR=596 +LEFT_BRACKET=597 +RIGHT_BRACKET=598 +EQUAL_GTH=599 +COLON_EQUAL=600 +LESS_LESS=601 +GREATER_GREATER=602 +DOUBLE_DOT=603 +HASH_SIGN=604 +BlockComment=605 +LineComment=606 +OP_CHARS=607 +NUMBER_LITERAL=608 +REAL_NUMBER=609 +DOLLAR_NUMBER=610 +Identifier=611 +QuotedIdentifier=612 +Character_String_Literal=613 +BeginDollarStringConstant=614 +Space=615 +White_Space=616 +New_Line=617 +Tab=618 +BOM=619 +BAD=620 +Text_between_Dollar=621 +EndDollarStringConstant=622 +'='=576 +':'=577 +';'=578 +','=579 +'<'=581 +'<='=582 +'>'=583 +'>='=584 +'('=585 +')'=586 +'+'=587 +'-'=588 +'*'=589 +'/'=590 +'%'=591 +'^'=592 +'.'=593 +'\''=594 +'"'=595 +'$'=596 +'['=597 +']'=598 +'=>'=599 +':='=600 +'<<'=601 +'>>'=602 +'..'=603 +'#'=604 +' '=615 +'\u0009'=618 +'\ufeff'=619 diff --git a/sql_to_code/parsers/generated/PLpgSQLParser.g4 b/sql_to_code/parsers/generated/PLpgSQLParser.g4 new file mode 100644 index 0000000..7ffd062 --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLParser.g4 @@ -0,0 +1,3094 @@ +parser grammar PLpgSQLParser; + +options { + language=Java; + tokenVocab=PLpgSQLLexer; +} + + +// to start parsing, it is recommended to use only rules with EOF +// this eliminates the ambiguous parsing options and speeds up the process +/******* Start symbols *******/ + +sql + : BOM? SEMI_COLON* (statement (SEMI_COLON+ | EOF))* EOF + ; + +qname_parser + : schema_qualified_name EOF + ; + +function_args_parser + : schema_qualified_name? function_args EOF + ; + +vex_eof + : vex (COMMA vex)* EOF + ; + +plpgsql_function + : comp_options? function_block SEMI_COLON? EOF + ; + +plpgsql_function_test_list + : (comp_options? function_block SEMI_COLON)* EOF + ; + +/******* END Start symbols *******/ + +statement + : data_statement + | schema_statement + | script_statement + ; + +data_statement + : select_stmt + | insert_stmt_for_psql + | update_stmt_for_psql + | delete_stmt_for_psql + ; + +script_statement + : script_transaction + | script_additional + ; + +script_transaction + : (START TRANSACTION | BEGIN (WORK | TRANSACTION)?) (transaction_mode (COMMA transaction_mode)*)? + | (COMMIT | END | ABORT | ROLLBACK) (WORK | TRANSACTION)? (AND NO? CHAIN)? + | (COMMIT PREPARED | PREPARE TRANSACTION) Character_String_Literal + | (SAVEPOINT | RELEASE SAVEPOINT?) identifier + | ROLLBACK PREPARED Character_String_Literal + | ROLLBACK (WORK | TRANSACTION)? TO SAVEPOINT? identifier + | lock_table + ; + +transaction_mode + : ISOLATION LEVEL (SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED) + | READ WRITE + | READ ONLY + | NOT? DEFERRABLE + ; + +lock_table + : LOCK TABLE? only_table_multiply (COMMA only_table_multiply)* (IN lock_mode MODE)? NOWAIT? + ; + +lock_mode + : (ROW | ACCESS) SHARE + | ROW EXCLUSIVE + | SHARE (ROW | UPDATE) EXCLUSIVE + | SHARE + | ACCESS? EXCLUSIVE + ; + +script_additional + : additional_statement + | VACUUM vacuum_mode table_cols_list? + | (FETCH | MOVE) fetch_move_direction? (FROM | IN)? identifier + | CLOSE (identifier | ALL) + | CALL function_call + | DISCARD (ALL | PLANS | SEQUENCES | TEMPORARY | TEMP) + | declare_statement + | execute_statement + | explain_statement + | show_statement + ; + +additional_statement + : anonymous_block + | LISTEN identifier + | UNLISTEN (identifier | MULTIPLY) + | ANALYZE (LEFT_PAREN analyze_mode (COMMA analyze_mode)* RIGHT_PAREN | VERBOSE)? table_cols_list? + | CLUSTER VERBOSE? (identifier ON schema_qualified_name | schema_qualified_name (USING identifier)?)? + | CHECKPOINT + | LOAD Character_String_Literal + | DEALLOCATE PREPARE? (identifier | ALL) + | REINDEX (LEFT_PAREN VERBOSE RIGHT_PAREN)? (INDEX | TABLE | SCHEMA | DATABASE | SYSTEM) CONCURRENTLY? schema_qualified_name + | RESET ((identifier DOT)? identifier | TIME ZONE | SESSION AUTHORIZATION | ALL) + | REFRESH MATERIALIZED VIEW CONCURRENTLY? schema_qualified_name (WITH NO? DATA)? + | PREPARE identifier (LEFT_PAREN data_type (COMMA data_type)* RIGHT_PAREN)? AS data_statement + | REASSIGN OWNED BY user_name (COMMA user_name)* TO user_name + | copy_statement + | truncate_stmt + | notify_stmt + ; + +explain_statement + : EXPLAIN (ANALYZE? VERBOSE? | LEFT_PAREN explain_option (COMMA explain_option)* RIGHT_PAREN) explain_query; + +explain_query + : data_statement + | execute_statement + | declare_statement + | CREATE (create_table_as_statement | create_view_statement) + ; + +execute_statement + : EXECUTE identifier (LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN)? + ; + +declare_statement + : DECLARE identifier BINARY? INSENSITIVE? (NO? SCROLL)? CURSOR ((WITH | WITHOUT) HOLD)? FOR select_stmt + ; + +show_statement + : SHOW ((identifier DOT)? identifier | ALL | TIME ZONE | TRANSACTION ISOLATION LEVEL | SESSION AUTHORIZATION) + ; + +explain_option + : (ANALYZE | VERBOSE | COSTS | SETTINGS | BUFFERS | TIMING | SUMMARY) boolean_value? + | FORMAT (TEXT | XML | JSON | YAML) + ; + +user_name + : identifier | CURRENT_USER | SESSION_USER + ; + +table_cols_list + : table_cols (COMMA table_cols)* + ; + +table_cols + : schema_qualified_name (LEFT_PAREN identifier (COMMA identifier)* RIGHT_PAREN)? + ; + +vacuum_mode + : LEFT_PAREN vacuum_option (COMMA vacuum_option)* RIGHT_PAREN + | FULL? FREEZE? VERBOSE? ANALYZE? + ; + +vacuum_option + : (FULL | FREEZE | VERBOSE | ANALYZE | DISABLE_PAGE_SKIPPING | SKIP_LOCKED | INDEX_CLEANUP | TRUNCATE) boolean_value? + ; + +analyze_mode + : (VERBOSE | SKIP_LOCKED) boolean_value? + ; + +boolean_value + : TRUE + | FALSE + | OFF + | ON + | NUMBER_LITERAL + ; + +fetch_move_direction + : NEXT + | PRIOR + | FIRST + | LAST + | (ABSOLUTE | RELATIVE)? signed_number_literal + | ALL + | FORWARD (NUMBER_LITERAL | ALL)? + | BACKWARD (NUMBER_LITERAL | ALL)? + ; + +schema_statement + : schema_create + | schema_alter + | schema_drop + ; + +schema_create + : CREATE (create_table_statement + | create_foreign_table_statement + | create_index_statement + | create_extension_statement + | create_trigger_statement + | create_rewrite_statement + | create_function_statement + | create_sequence_statement + | create_schema_statement + | create_view_statement + | create_language_statement + | create_event_trigger + | create_type_statement + | create_domain_statement + | create_server_statement + | create_fts_configuration + | create_fts_template + | create_fts_parser + | create_fts_dictionary + | create_collation + | create_user_mapping + | create_transform_statement + | create_access_method + | create_user_or_role + | create_group + | create_tablespace + | create_statistics + | create_foreign_data_wrapper + | create_operator_statement + | create_aggregate_statement + | create_table_as_statement + | create_policy_statement + | create_subscription_statement + | create_cast_statement + | create_operator_family_statement + | create_operator_class_statement + | create_conversion_statement + | create_publication_statement) + + | comment_on_statement + | rule_common + | set_statement + | schema_import + | security_label + ; + +schema_alter + : ALTER (alter_function_statement + | alter_schema_statement + | alter_language_statement + | alter_table_statement + | alter_index_statement + | alter_default_privileges + | alter_sequence_statement + | alter_view_statement + | alter_event_trigger + | alter_type_statement + | alter_domain_statement + | alter_server_statement + | alter_fts_statement + | alter_collation + | alter_user_mapping + | alter_user_or_role + | alter_group + | alter_tablespace + | alter_statistics + | alter_foreign_data_wrapper + | alter_operator_statement + | alter_aggregate_statement + | alter_extension_statement + | alter_policy_statement + | alter_subscription_statement + | alter_trigger_statement + | alter_rule_statement + | alter_operator_family_statement + | alter_operator_class_statement + | alter_conversion_statement + | alter_publication_statement + | alter_owner) + ; + +schema_drop + : DROP (drop_function_statement + | drop_trigger_statement + | drop_rule_statement + | drop_policy_statement + | drop_cast_statement + | drop_operator_family_statement + | drop_operator_class_statement + | drop_statements + | drop_user_mapping + | drop_owned + | drop_operator_statement) + ; + +schema_import + : IMPORT FOREIGN SCHEMA name=identifier + ((LIMIT TO | EXCEPT) LEFT_PAREN identifier_list RIGHT_PAREN)? + FROM SERVER identifier INTO identifier + define_foreign_options? + ; + +alter_function_statement + : (FUNCTION | PROCEDURE) function_parameters? + ((function_actions_common | RESET ((identifier DOT)? identifier | ALL))+ RESTRICT? + | rename_to + | set_schema + | DEPENDS ON EXTENSION identifier) + ; + +alter_aggregate_statement + : AGGREGATE function_parameters (rename_to | set_schema) + ; + +alter_extension_statement + : EXTENSION identifier alter_extension_action + ; + +alter_extension_action + : set_schema + | UPDATE (TO (identifier | character_string))? + | (ADD | DROP) extension_member_object + ; + +extension_member_object + : ACCESS METHOD schema_qualified_name + | AGGREGATE function_parameters + | CAST LEFT_PAREN schema_qualified_name AS schema_qualified_name RIGHT_PAREN + | COLLATION identifier + | CONVERSION identifier + | DOMAIN schema_qualified_name + | EVENT TRIGGER identifier + | FOREIGN DATA WRAPPER identifier + | FOREIGN TABLE schema_qualified_name + | FUNCTION function_parameters + | MATERIALIZED? VIEW schema_qualified_name + | OPERATOR operator_name + | OPERATOR CLASS schema_qualified_name USING identifier + | OPERATOR FAMILY schema_qualified_name USING identifier + | PROCEDURAL? LANGUAGE identifier + | PROCEDURE function_parameters + | ROUTINE function_parameters + | SCHEMA identifier + | SEQUENCE schema_qualified_name + | SERVER identifier + | TABLE schema_qualified_name + | TEXT SEARCH CONFIGURATION schema_qualified_name + | TEXT SEARCH DICTIONARY schema_qualified_name + | TEXT SEARCH PARSER schema_qualified_name + | TEXT SEARCH TEMPLATE schema_qualified_name + | TRANSFORM FOR identifier LANGUAGE identifier + | TYPE schema_qualified_name + ; + +alter_schema_statement + : SCHEMA identifier rename_to + ; + +alter_language_statement + : PROCEDURAL? LANGUAGE name=identifier (rename_to | owner_to) + ; + +alter_table_statement + : FOREIGN? TABLE if_exists? ONLY? name=schema_qualified_name MULTIPLY?( + table_action (COMMA table_action)* + | RENAME COLUMN? identifier TO identifier + | set_schema + | rename_to + | RENAME CONSTRAINT identifier TO identifier + | ATTACH PARTITION child=schema_qualified_name for_values_bound + | DETACH PARTITION child=schema_qualified_name) + ; + +table_action + : ADD COLUMN? if_not_exists? table_column_definition + | DROP COLUMN? if_exists? column=identifier cascade_restrict? + | ALTER COLUMN? column=identifier column_action + | ADD tabl_constraint=constraint_common (NOT not_valid=VALID)? + | validate_constraint + | drop_constraint + | (DISABLE | ENABLE) TRIGGER (trigger_name=schema_qualified_name | ALL | USER)? + | ENABLE (REPLICA | ALWAYS) TRIGGER trigger_name=schema_qualified_name + | (DISABLE | ENABLE) RULE rewrite_rule_name=schema_qualified_name + | ENABLE (REPLICA | ALWAYS) RULE rewrite_rule_name=schema_qualified_name + | (DISABLE | ENABLE) ROW LEVEL SECURITY + | NO? FORCE ROW LEVEL SECURITY + | CLUSTER ON index_name=schema_qualified_name + | SET WITHOUT (CLUSTER | OIDS) + | SET WITH OIDS + | SET (LOGGED | UNLOGGED) + | SET storage_parameter + | RESET names_in_parens + | define_foreign_options + | INHERIT parent_table=schema_qualified_name + | NO INHERIT parent_table=schema_qualified_name + | OF type_name=schema_qualified_name + | NOT OF + | owner_to + | SET table_space + | REPLICA IDENTITY (DEFAULT | FULL | NOTHING | USING INDEX identifier) + | ALTER CONSTRAINT identifier table_deferrable? table_initialy_immed? + ; + +column_action + : (SET DATA)? TYPE data_type collate_identifier? (USING vex)? + | ADD identity_body + | set_def_column + | drop_def + | (set=SET | DROP) NOT NULL + | DROP IDENTITY if_exists? + | SET storage_parameter + | SET STATISTICS signed_number_literal + | SET STORAGE storage_option + | RESET names_in_parens + | define_foreign_options + | alter_identity+ + ; + +identity_body + : GENERATED (ALWAYS | BY DEFAULT) AS IDENTITY (LEFT_PAREN sequence_body+ RIGHT_PAREN)? + ; + +alter_identity + : SET GENERATED (ALWAYS | BY DEFAULT) + | SET sequence_body + | RESTART (WITH? NUMBER_LITERAL)? + ; + +storage_option + : PLAIN + | EXTERNAL + | EXTENDED + | MAIN + ; + +validate_constraint + : VALIDATE CONSTRAINT constraint_name=schema_qualified_name + ; + +drop_constraint + : DROP CONSTRAINT if_exists? constraint_name=identifier cascade_restrict? + ; + +table_deferrable + : NOT? DEFERRABLE + ; + +table_initialy_immed + : INITIALLY (DEFERRED | IMMEDIATE) + ; + +function_actions_common + : (CALLED | RETURNS NULL) ON NULL INPUT + | TRANSFORM transform_for_type (COMMA transform_for_type)* + | STRICT + | IMMUTABLE + | VOLATILE + | STABLE + | NOT? LEAKPROOF + | EXTERNAL? SECURITY (INVOKER | DEFINER) + | PARALLEL (SAFE | UNSAFE | RESTRICTED) + | COST execution_cost=unsigned_numeric_literal + | ROWS result_rows=unsigned_numeric_literal + | SUPPORT schema_qualified_name + | SET (config_scope=identifier DOT)? config_param=identifier ((TO | EQUAL) set_statement_value | FROM CURRENT) + | LANGUAGE lang_name=identifier + | WINDOW + | AS function_def + ; + +function_def + : definition=character_string (COMMA symbol=character_string)? + ; + +alter_index_statement + : INDEX if_exists? schema_qualified_name index_def_action + | INDEX ALL IN TABLESPACE identifier (OWNED BY identifier_list)? SET TABLESPACE identifier NOWAIT? + ; + +index_def_action + : rename_to + | ATTACH PARTITION index=schema_qualified_name + | DEPENDS ON EXTENSION schema_qualified_name + | ALTER COLUMN? sign? NUMBER_LITERAL SET STATISTICS signed_number_literal + | RESET LEFT_PAREN identifier_list RIGHT_PAREN + | SET TABLESPACE identifier + | SET LEFT_PAREN option_with_value (COMMA option_with_value)* RIGHT_PAREN + ; + +alter_default_privileges + : DEFAULT PRIVILEGES + (FOR (ROLE | USER) identifier_list)? + (IN SCHEMA identifier_list)? + abbreviated_grant_or_revoke + ; + +abbreviated_grant_or_revoke + : (GRANT | REVOKE grant_option_for?) ( + table_column_privilege (COMMA table_column_privilege)* ON TABLES + | (usage_select_update (COMMA usage_select_update)* | ALL PRIVILEGES?) ON SEQUENCES + | (EXECUTE | ALL PRIVILEGES?) ON FUNCTIONS + | (USAGE | CREATE | ALL PRIVILEGES?) ON SCHEMAS + | (USAGE | ALL PRIVILEGES?) ON TYPES) + (grant_to_rule | revoke_from_cascade_restrict) + ; + +grant_option_for + : GRANT OPTION FOR + ; + +alter_sequence_statement + : SEQUENCE if_exists? name=schema_qualified_name + ( (sequence_body | RESTART (WITH? signed_number_literal)?)* + | set_schema + | rename_to) + ; + +alter_view_statement + : MATERIALIZED? VIEW if_exists? name=schema_qualified_name + (ALTER COLUMN? column_name=schema_qualified_name (set_def_column | drop_def) + | set_schema + | rename_to + | SET storage_parameter + | RESET names_in_parens) + ; + +alter_event_trigger + : EVENT TRIGGER name=identifier alter_event_trigger_action + ; + +alter_event_trigger_action + : DISABLE + | ENABLE (REPLICA | ALWAYS)? + | owner_to + | rename_to + ; + +alter_type_statement + : TYPE name=schema_qualified_name + (set_schema + | rename_to + | ADD VALUE if_not_exists? new_enum_value=character_string ((BEFORE | AFTER) existing_enum_value=character_string)? + | RENAME ATTRIBUTE attribute_name=identifier TO new_attribute_name=identifier cascade_restrict? + | RENAME VALUE existing_enum_name=character_string TO new_enum_name=character_string + | type_action (COMMA type_action)*) + ; + +alter_domain_statement + : DOMAIN name=schema_qualified_name + (set_def_column + | drop_def + | (SET | DROP) NOT NULL + | ADD dom_constraint=domain_constraint (NOT not_valid=VALID)? + | drop_constraint + | RENAME CONSTRAINT schema_qualified_name TO schema_qualified_name + | validate_constraint + | rename_to + | set_schema) + ; + +alter_server_statement + : SERVER identifier alter_server_action + ; + +alter_server_action + : (VERSION character_string)? define_foreign_options + | VERSION character_string + | owner_to + | rename_to + ; + +alter_fts_statement + : TEXT SEARCH + ((TEMPLATE | DICTIONARY | CONFIGURATION | PARSER) name=schema_qualified_name (rename_to | set_schema) + | DICTIONARY name=schema_qualified_name storage_parameter + | CONFIGURATION name=schema_qualified_name alter_fts_configuration) + ; + +alter_fts_configuration + : (ADD | ALTER) MAPPING FOR identifier_list WITH schema_qualified_name (COMMA schema_qualified_name)* + | ALTER MAPPING (FOR identifier_list)? REPLACE schema_qualified_name WITH schema_qualified_name + | DROP MAPPING (IF EXISTS)? FOR identifier_list + ; + +type_action + : ADD ATTRIBUTE identifier data_type collate_identifier? cascade_restrict? + | DROP ATTRIBUTE if_exists? identifier cascade_restrict? + | ALTER ATTRIBUTE identifier (SET DATA)? TYPE data_type collate_identifier? cascade_restrict? + ; + +set_def_column + : SET DEFAULT vex + ; + +drop_def + : DROP DEFAULT + ; + +create_index_statement + : UNIQUE? INDEX CONCURRENTLY? if_not_exists? name=identifier? ON ONLY? table_name=schema_qualified_name index_rest + ; + +index_rest + : (USING method=identifier)? index_sort including_index? with_storage_parameter? table_space? index_where? + ; + +index_sort + : LEFT_PAREN sort_specifier_list RIGHT_PAREN + ; + +including_index + : INCLUDE LEFT_PAREN identifier (COMMA identifier)* RIGHT_PAREN + ; + +index_where + : WHERE vex + ; + + create_extension_statement + : EXTENSION if_not_exists? name=identifier + WITH? + (SCHEMA schema=identifier)? + (VERSION (identifier | character_string))? + (FROM (identifier | character_string))? + CASCADE? + ; + +create_language_statement + : (OR REPLACE)? TRUSTED? PROCEDURAL? LANGUAGE name=identifier + (HANDLER schema_qualified_name (INLINE schema_qualified_name)? (VALIDATOR schema_qualified_name)?)? + ; + +create_event_trigger + : EVENT TRIGGER name=identifier ON identifier + (WHEN (schema_qualified_name IN LEFT_PAREN character_string (COMMA character_string)* RIGHT_PAREN AND?)+ )? + EXECUTE (PROCEDURE | FUNCTION) vex + ; + +create_type_statement + : TYPE name=schema_qualified_name (AS( + LEFT_PAREN (attrs+=table_column_definition (COMMA attrs+=table_column_definition)*)? RIGHT_PAREN + | ENUM LEFT_PAREN ( enums+=character_string (COMMA enums+=character_string)* )? RIGHT_PAREN + | RANGE LEFT_PAREN + (SUBTYPE EQUAL subtype_name=data_type + | SUBTYPE_OPCLASS EQUAL subtype_operator_class=identifier + | COLLATION EQUAL collation=schema_qualified_name + | CANONICAL EQUAL canonical_function=schema_qualified_name + | SUBTYPE_DIFF EQUAL subtype_diff_function=schema_qualified_name)? + (COMMA (SUBTYPE EQUAL subtype_name=data_type + | SUBTYPE_OPCLASS EQUAL subtype_operator_class=identifier + | COLLATION EQUAL collation=schema_qualified_name + | CANONICAL EQUAL canonical_function=schema_qualified_name + | SUBTYPE_DIFF EQUAL subtype_diff_function=schema_qualified_name))* + RIGHT_PAREN) + | LEFT_PAREN + // pg_dump prints internallength first + (INTERNALLENGTH EQUAL (internallength=signed_numerical_literal | VARIABLE) COMMA)? + INPUT EQUAL input_function=schema_qualified_name COMMA + OUTPUT EQUAL output_function=schema_qualified_name + (COMMA (RECEIVE EQUAL receive_function=schema_qualified_name + | SEND EQUAL send_function=schema_qualified_name + | TYPMOD_IN EQUAL type_modifier_input_function=schema_qualified_name + | TYPMOD_OUT EQUAL type_modifier_output_function=schema_qualified_name + | ANALYZE EQUAL analyze_function=schema_qualified_name + | INTERNALLENGTH EQUAL (internallength=signed_numerical_literal | VARIABLE ) + | PASSEDBYVALUE + | ALIGNMENT EQUAL alignment=data_type + | STORAGE EQUAL storage=(PLAIN | EXTERNAL | EXTENDED | MAIN) + | LIKE EQUAL like_type=data_type + | CATEGORY EQUAL category=character_string + | PREFERRED EQUAL preferred=truth_value + | DEFAULT EQUAL default_value=vex + | ELEMENT EQUAL element=data_type + | DELIMITER EQUAL delimiter=character_string + | COLLATABLE EQUAL collatable=truth_value))* + RIGHT_PAREN)? + ; + +create_domain_statement + : DOMAIN name=schema_qualified_name AS? dat_type=data_type + (collate_identifier | DEFAULT def_value=vex | dom_constraint+=domain_constraint)* + ; + +create_server_statement + : SERVER if_not_exists? identifier (TYPE character_string)? (VERSION character_string)? + FOREIGN DATA WRAPPER identifier + define_foreign_options? + ; + +create_fts_dictionary + : TEXT SEARCH DICTIONARY name=schema_qualified_name + LEFT_PAREN + TEMPLATE EQUAL template=schema_qualified_name (COMMA option_with_value)* + RIGHT_PAREN + ; + +option_with_value + : identifier EQUAL vex + ; + +create_fts_configuration + : TEXT SEARCH CONFIGURATION name=schema_qualified_name + LEFT_PAREN + (PARSER EQUAL parser_name=schema_qualified_name + | COPY EQUAL config_name=schema_qualified_name) + RIGHT_PAREN + ; + +create_fts_template + : TEXT SEARCH TEMPLATE name=schema_qualified_name + LEFT_PAREN + (INIT EQUAL init_name=schema_qualified_name COMMA)? + LEXIZE EQUAL lexize_name=schema_qualified_name + (COMMA INIT EQUAL init_name=schema_qualified_name)? + RIGHT_PAREN + ; + +create_fts_parser + : TEXT SEARCH PARSER name=schema_qualified_name + LEFT_PAREN + START EQUAL start_func=schema_qualified_name COMMA + GETTOKEN EQUAL gettoken_func=schema_qualified_name COMMA + END EQUAL end_func=schema_qualified_name COMMA + (HEADLINE EQUAL headline_func=schema_qualified_name COMMA)? + LEXTYPES EQUAL lextypes_func=schema_qualified_name + (COMMA HEADLINE EQUAL headline_func=schema_qualified_name)? + RIGHT_PAREN + ; + +create_collation + : COLLATION if_not_exists? name=schema_qualified_name + (FROM schema_qualified_name | LEFT_PAREN (collation_option (COMMA collation_option)*)? RIGHT_PAREN) + ; + +alter_collation + : COLLATION name=schema_qualified_name (REFRESH VERSION | rename_to | owner_to | set_schema) + ; + +collation_option + : (LOCALE | LC_COLLATE | LC_CTYPE | PROVIDER | VERSION) EQUAL (character_string | identifier) + | DETERMINISTIC EQUAL boolean_value + ; + +create_user_mapping + : USER MAPPING if_not_exists? FOR (user_name | USER) SERVER identifier define_foreign_options? + ; + +alter_user_mapping + : USER MAPPING FOR (user_name | USER) SERVER identifier define_foreign_options? + ; + +alter_user_or_role + : (USER | ROLE) (alter_user_or_role_set_reset | identifier rename_to | user_name WITH? user_or_role_option_for_alter+) + ; + +alter_user_or_role_set_reset + : (user_name | ALL) (IN DATABASE identifier)? user_or_role_set_reset + ; + +user_or_role_set_reset + : SET (identifier DOT)? identifier (TO | EQUAL) set_statement_value + | SET (identifier DOT)? identifier FROM CURRENT + | RESET (identifier DOT)? identifier + | RESET ALL + ; + +alter_group + : GROUP alter_group_action + ; + +alter_group_action + : name=identifier rename_to + | user_name (ADD | DROP) USER identifier_list + ; + +alter_tablespace + : TABLESPACE name=identifier alter_tablespace_action + ; + +alter_owner + : (OPERATOR target_operator + | LARGE OBJECT NUMBER_LITERAL + | (FUNCTION | PROCEDURE | AGGREGATE) name=schema_qualified_name function_args + | (TEXT SEARCH DICTIONARY | TEXT SEARCH CONFIGURATION | DOMAIN | SCHEMA | SEQUENCE | TYPE | MATERIALIZED? VIEW) + if_exists? name=schema_qualified_name) owner_to + ; + +alter_tablespace_action + : rename_to + | owner_to + | SET LEFT_PAREN option_with_value (COMMA option_with_value)* RIGHT_PAREN + | RESET LEFT_PAREN identifier_list RIGHT_PAREN + ; + +alter_statistics + : STATISTICS name=schema_qualified_name (rename_to | set_schema | owner_to) + ; + +alter_foreign_data_wrapper + : FOREIGN DATA WRAPPER name=identifier alter_foreign_data_wrapper_action + ; + +alter_foreign_data_wrapper_action + : (HANDLER schema_qualified_name_nontype | NO HANDLER )? (VALIDATOR schema_qualified_name_nontype | NO VALIDATOR)? define_foreign_options? + | owner_to + | rename_to + ; + +alter_operator_statement + : OPERATOR target_operator alter_operator_action + ; + +alter_operator_action + : set_schema + | SET LEFT_PAREN operator_set_restrict_join (COMMA operator_set_restrict_join)* RIGHT_PAREN + ; + +operator_set_restrict_join + : (RESTRICT | JOIN) EQUAL schema_qualified_name + ; + +drop_user_mapping + : USER MAPPING if_exists? FOR (user_name | USER) SERVER identifier + ; + +drop_owned + : OWNED BY user_name (COMMA user_name)* cascade_restrict? + ; + +drop_operator_statement + : OPERATOR if_exists? target_operator (COMMA target_operator)* cascade_restrict? + ; + +target_operator + : name=operator_name LEFT_PAREN (left_type=data_type | NONE) COMMA (right_type=data_type | NONE) RIGHT_PAREN + ; + +domain_constraint + : (CONSTRAINT name=identifier)? (CHECK LEFT_PAREN vex RIGHT_PAREN | NOT? NULL) + ; + +create_transform_statement + : (OR REPLACE)? TRANSFORM FOR data_type LANGUAGE identifier + LEFT_PAREN + FROM SQL WITH FUNCTION function_parameters COMMA + TO SQL WITH FUNCTION function_parameters + RIGHT_PAREN + ; + +create_access_method + : ACCESS METHOD identifier TYPE (TABLE | INDEX) HANDLER schema_qualified_name + ; + +create_user_or_role + : (USER | ROLE) name=identifier (WITH? user_or_role_option user_or_role_option*)? + ; + +user_or_role_option + : user_or_role_or_group_common_option + | user_or_role_common_option + | user_or_role_or_group_option_for_create + ; + +user_or_role_option_for_alter + : user_or_role_or_group_common_option + | user_or_role_common_option + ; + +user_or_role_or_group_common_option + : SUPERUSER | NOSUPERUSER + | CREATEDB | NOCREATEDB + | CREATEROLE | NOCREATEROLE + | INHERIT | NOINHERIT + | LOGIN | NOLOGIN + | ENCRYPTED? PASSWORD (password=Character_String_Literal | NULL) + | VALID UNTIL date_time=Character_String_Literal + ; + +user_or_role_common_option + : REPLICATION | NOREPLICATION + | BYPASSRLS | NOBYPASSRLS + | CONNECTION LIMIT signed_number_literal + ; + +user_or_role_or_group_option_for_create + : SYSID vex + | (IN ROLE | IN GROUP | ROLE | ADMIN | USER) identifier_list + ; + +create_group + : GROUP name=identifier (WITH? group_option+)? + ; + +group_option + : user_or_role_or_group_common_option + | user_or_role_or_group_option_for_create + ; + +create_tablespace + : TABLESPACE name=identifier (OWNER user_name)? + LOCATION directory=Character_String_Literal + (WITH LEFT_PAREN option_with_value (COMMA option_with_value)* RIGHT_PAREN)? + ; + +create_statistics + : STATISTICS if_not_exists? name=schema_qualified_name + (LEFT_PAREN identifier_list RIGHT_PAREN)? + ON identifier COMMA identifier_list + FROM schema_qualified_name + ; + +create_foreign_data_wrapper + : FOREIGN DATA WRAPPER name=identifier (HANDLER schema_qualified_name_nontype | NO HANDLER )? + (VALIDATOR schema_qualified_name_nontype | NO VALIDATOR)? + (OPTIONS LEFT_PAREN option_without_equal (COMMA option_without_equal)* RIGHT_PAREN )? + ; + +option_without_equal + : identifier Character_String_Literal + ; + +create_operator_statement + : OPERATOR name=operator_name LEFT_PAREN operator_option (COMMA operator_option)* RIGHT_PAREN + ; + +operator_name + : (schema_name=identifier DOT)? operator=all_simple_op + ; + +operator_option + : (FUNCTION | PROCEDURE) EQUAL func_name=schema_qualified_name + | RESTRICT EQUAL restr_name=schema_qualified_name + | JOIN EQUAL join_name=schema_qualified_name + | (LEFTARG | RIGHTARG) EQUAL type=data_type + | (COMMUTATOR | NEGATOR) EQUAL addition_oper_name=all_op_ref + | HASHES + | MERGES + ; + +create_aggregate_statement + : (OR REPLACE)? AGGREGATE name=schema_qualified_name function_args? LEFT_PAREN + (BASETYPE EQUAL base_type=data_type COMMA)? + SFUNC EQUAL sfunc_name=schema_qualified_name COMMA + STYPE EQUAL type=data_type + (COMMA aggregate_param)* + RIGHT_PAREN + ; + +aggregate_param + : SSPACE EQUAL s_space=NUMBER_LITERAL + | FINALFUNC EQUAL final_func=schema_qualified_name + | FINALFUNC_EXTRA + | FINALFUNC_MODIFY EQUAL (READ_ONLY | SHAREABLE | READ_WRITE) + | COMBINEFUNC EQUAL combine_func=schema_qualified_name + | SERIALFUNC EQUAL serial_func=schema_qualified_name + | DESERIALFUNC EQUAL deserial_func=schema_qualified_name + | INITCOND EQUAL init_cond=vex + | MSFUNC EQUAL ms_func=schema_qualified_name + | MINVFUNC EQUAL minv_func=schema_qualified_name + | MSTYPE EQUAL ms_type=data_type + | MSSPACE EQUAL ms_space=NUMBER_LITERAL + | MFINALFUNC EQUAL mfinal_func=schema_qualified_name + | MFINALFUNC_EXTRA + | MFINALFUNC_MODIFY EQUAL (READ_ONLY | SHAREABLE | READ_WRITE) + | MINITCOND EQUAL minit_cond=vex + | SORTOP EQUAL all_op_ref + | PARALLEL EQUAL (SAFE | RESTRICTED | UNSAFE) + | HYPOTHETICAL + ; + +set_statement + : SET set_action + ; + +set_action + : CONSTRAINTS (ALL | names_references) (DEFERRED | IMMEDIATE) + | TRANSACTION transaction_mode (COMMA transaction_mode)* + | TRANSACTION SNAPSHOT Character_String_Literal + | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode (COMMA transaction_mode)* + | (SESSION | LOCAL)? session_local_option + | XML OPTION (DOCUMENT | CONTENT) + ; + +session_local_option + : SESSION AUTHORIZATION (Character_String_Literal | identifier | DEFAULT) + | TIME ZONE (Character_String_Literal | signed_numerical_literal | LOCAL | DEFAULT) + | (identifier DOT)? config_param=identifier (TO | EQUAL) set_statement_value + | ROLE (identifier | NONE) + ; + +set_statement_value + : vex (COMMA vex)* + | DEFAULT + ; + +create_rewrite_statement + : (OR REPLACE)? RULE name=identifier AS ON event=(SELECT | INSERT | DELETE | UPDATE) + TO table_name=schema_qualified_name (WHERE vex)? DO (ALSO | INSTEAD)? + (NOTHING + | rewrite_command + | (LEFT_PAREN (rewrite_command SEMI_COLON)* rewrite_command SEMI_COLON? RIGHT_PAREN) + ) + ; + +rewrite_command + : select_stmt + | insert_stmt_for_psql + | update_stmt_for_psql + | delete_stmt_for_psql + | notify_stmt + ; + +create_trigger_statement + : CONSTRAINT? TRIGGER name=identifier (before_true=BEFORE | (INSTEAD OF) | AFTER) + (((insert_true=INSERT | delete_true=DELETE | truncate_true=TRUNCATE) + | update_true=UPDATE (OF identifier_list)?)OR?)+ + ON table_name=schema_qualified_name + (FROM referenced_table_name=schema_qualified_name)? + table_deferrable? table_initialy_immed? + (REFERENCING trigger_referencing trigger_referencing?)? + (for_each_true=FOR EACH? (ROW | STATEMENT))? + when_trigger? + EXECUTE (FUNCTION | PROCEDURE) func_name=function_call + ; + +trigger_referencing + : (OLD | NEW) TABLE AS? identifier + ; + +when_trigger + : WHEN LEFT_PAREN vex RIGHT_PAREN + ; + +rule_common + : (GRANT | REVOKE grant_option_for?) + (permissions | columns_permissions) + ON rule_member_object + (TO | FROM) roles_names (WITH GRANT OPTION | cascade_restrict)? + | other_rules + ; + +rule_member_object + : TABLE? table_names=names_references + | SEQUENCE names_references + | DATABASE names_references + | DOMAIN names_references + | FOREIGN DATA WRAPPER names_references + | FOREIGN SERVER names_references + | (FUNCTION | PROCEDURE | ROUTINE) func_name+=function_parameters (COMMA func_name+=function_parameters)* + | LARGE OBJECT NUMBER_LITERAL (COMMA NUMBER_LITERAL)* + | LANGUAGE names_references + | SCHEMA schema_names=names_references + | TABLESPACE names_references + | TYPE names_references + | ALL (TABLES | SEQUENCES | FUNCTIONS | PROCEDURES | ROUTINES) IN SCHEMA names_references + ; + +columns_permissions + : table_column_privileges (COMMA table_column_privileges)* + ; + +table_column_privileges + : table_column_privilege LEFT_PAREN identifier_list RIGHT_PAREN + ; + +permissions + : permission (COMMA permission)* + ; + +permission + : ALL PRIVILEGES? + | CONNECT + | CREATE + | DELETE + | EXECUTE + | INSERT + | UPDATE + | REFERENCES + | SELECT + | TEMP + | TRIGGER + | TRUNCATE + | USAGE + ; + +other_rules + : GRANT names_references TO names_references (WITH ADMIN OPTION)? + | REVOKE (ADMIN OPTION FOR)? names_references FROM names_references cascade_restrict? + ; + +grant_to_rule + : TO roles_names (WITH GRANT OPTION)? + ; + +revoke_from_cascade_restrict + : FROM roles_names cascade_restrict? + ; + +roles_names + : role_name_with_group (COMMA role_name_with_group)* + ; + +role_name_with_group + : GROUP? user_name + ; + +comment_on_statement + : COMMENT ON comment_member_object IS (character_string | NULL) + ; + +security_label + : SECURITY LABEL (FOR (identifier | character_string))? ON label_member_object IS (character_string | NULL) + ; + +comment_member_object + : ACCESS METHOD identifier + | (AGGREGATE | PROCEDURE | FUNCTION | ROUTINE) name=schema_qualified_name function_args + | CAST LEFT_PAREN source=data_type AS target=data_type RIGHT_PAREN + | COLLATION identifier + | COLUMN name=schema_qualified_name + | CONSTRAINT identifier ON DOMAIN? table_name=schema_qualified_name + | CONVERSION name=schema_qualified_name + | DATABASE identifier + | DOMAIN name=schema_qualified_name + | EXTENSION identifier + | EVENT TRIGGER identifier + | FOREIGN DATA WRAPPER identifier + | FOREIGN? TABLE name=schema_qualified_name + | INDEX name=schema_qualified_name + | LARGE OBJECT NUMBER_LITERAL + | MATERIALIZED? VIEW name=schema_qualified_name + | OPERATOR target_operator + | OPERATOR (FAMILY| CLASS) name=schema_qualified_name USING index_method=identifier + | POLICY identifier ON table_name=schema_qualified_name + | PROCEDURAL? LANGUAGE name=schema_qualified_name + | PUBLICATION identifier + | ROLE identifier + | RULE identifier ON table_name=schema_qualified_name + | SCHEMA identifier + | SEQUENCE name=schema_qualified_name + | SERVER identifier + | STATISTICS name=schema_qualified_name + | SUBSCRIPTION identifier + | TABLESPACE identifier + | TEXT SEARCH CONFIGURATION name=schema_qualified_name + | TEXT SEARCH DICTIONARY name=schema_qualified_name + | TEXT SEARCH PARSER name=schema_qualified_name + | TEXT SEARCH TEMPLATE name=schema_qualified_name + | TRANSFORM FOR name=schema_qualified_name LANGUAGE identifier + | TRIGGER identifier ON table_name=schema_qualified_name + | TYPE name=schema_qualified_name + ; + +label_member_object + : (AGGREGATE | PROCEDURE | FUNCTION | ROUTINE) schema_qualified_name function_args + | COLUMN schema_qualified_name + | DATABASE identifier + | DOMAIN schema_qualified_name + | EVENT TRIGGER identifier + | FOREIGN? TABLE schema_qualified_name + | LARGE OBJECT NUMBER_LITERAL + | MATERIALIZED? VIEW schema_qualified_name + | PROCEDURAL? LANGUAGE schema_qualified_name + | PUBLICATION identifier + | ROLE identifier + | SCHEMA identifier + | SEQUENCE schema_qualified_name + | SUBSCRIPTION identifier + | TABLESPACE identifier + | TYPE schema_qualified_name + ; + +/* +=============================================================================== + Function and Procedure Definition +=============================================================================== +*/ +create_function_statement + : (OR REPLACE)? (FUNCTION | PROCEDURE) function_parameters + (RETURNS (rettype_data=data_type | ret_table=function_ret_table))? + create_funct_params + ; + +create_funct_params + : function_actions_common+ with_storage_parameter? + ; + +transform_for_type + : FOR TYPE data_type + ; + +function_ret_table + : TABLE LEFT_PAREN function_column_name_type (COMMA function_column_name_type)* RIGHT_PAREN + ; + +function_column_name_type + : identifier data_type + ; + +function_parameters + : schema_qualified_name function_args + ; + +function_args + : LEFT_PAREN ((function_arguments (COMMA function_arguments)*)? agg_order? | MULTIPLY) RIGHT_PAREN + ; + +agg_order + : ORDER BY function_arguments (COMMA function_arguments)* + ; + +character_string + : BeginDollarStringConstant Text_between_Dollar* EndDollarStringConstant + | Character_String_Literal + ; + +function_arguments + : argmode? identifier_nontype? data_type ((DEFAULT | EQUAL) vex)? + ; + +argmode + : IN | OUT | INOUT | VARIADIC + ; + +create_sequence_statement + : (TEMPORARY | TEMP)? SEQUENCE if_not_exists? name=schema_qualified_name (sequence_body)* + ; + +sequence_body + : AS type=(SMALLINT | INTEGER | BIGINT) + | SEQUENCE NAME name=schema_qualified_name + | INCREMENT BY? incr=signed_numerical_literal + | (MINVALUE minval=signed_numerical_literal | NO MINVALUE) + | (MAXVALUE maxval=signed_numerical_literal | NO MAXVALUE) + | START WITH? start_val=signed_numerical_literal + | CACHE cache_val=signed_numerical_literal + | cycle_true=NO? cycle_val=CYCLE + | OWNED BY col_name=schema_qualified_name + ; + +signed_number_literal + : sign? NUMBER_LITERAL + ; + +signed_numerical_literal + : sign? unsigned_numeric_literal + ; + +sign + : PLUS | MINUS + ; + +create_schema_statement + : SCHEMA if_not_exists? name=identifier? (AUTHORIZATION user_name)? + ; + +create_policy_statement + : POLICY identifier ON schema_qualified_name + (AS (PERMISSIVE | RESTRICTIVE))? + (FOR event=(ALL | SELECT | INSERT | UPDATE | DELETE))? + (TO user_name (COMMA user_name)*)? + (USING using=vex)? (WITH CHECK check=vex)? + ; + +alter_policy_statement + : POLICY identifier ON schema_qualified_name rename_to + | POLICY identifier ON schema_qualified_name (TO user_name (COMMA user_name)*)? (USING vex)? (WITH CHECK vex)? + ; + +drop_policy_statement + : POLICY if_exists? identifier ON schema_qualified_name cascade_restrict? + ; + +create_subscription_statement + : SUBSCRIPTION identifier + CONNECTION Character_String_Literal + PUBLICATION identifier_list + with_storage_parameter? + ; + +alter_subscription_statement + : SUBSCRIPTION identifier alter_subscription_action + ; + +alter_subscription_action + : CONNECTION character_string + | SET PUBLICATION identifier_list with_storage_parameter? + | REFRESH PUBLICATION with_storage_parameter? + | ENABLE + | DISABLE + | SET storage_parameter + | owner_to + | rename_to + ; + +create_cast_statement + : CAST LEFT_PAREN source=data_type AS target=data_type RIGHT_PAREN + (WITH FUNCTION func_name=schema_qualified_name function_args | WITHOUT FUNCTION | WITH INOUT) + (AS ASSIGNMENT | AS IMPLICIT)? + ; + +drop_cast_statement + : CAST if_exists? LEFT_PAREN source=data_type AS target=data_type RIGHT_PAREN cascade_restrict? + ; + +create_operator_family_statement + : OPERATOR FAMILY schema_qualified_name USING identifier + ; + +alter_operator_family_statement + : OPERATOR FAMILY schema_qualified_name USING identifier operator_family_action + ; + +operator_family_action + : rename_to + | owner_to + | set_schema + | ADD add_operator_to_family (COMMA add_operator_to_family)* + | DROP drop_operator_from_family (COMMA drop_operator_from_family)* + ; + +add_operator_to_family + : OPERATOR unsigned_numeric_literal target_operator (FOR SEARCH | FOR ORDER BY schema_qualified_name)? + | FUNCTION unsigned_numeric_literal (LEFT_PAREN (data_type | NONE) (COMMA (data_type | NONE))? RIGHT_PAREN)? function_call + ; + +drop_operator_from_family + : (OPERATOR | FUNCTION) unsigned_numeric_literal LEFT_PAREN (data_type | NONE) (COMMA (data_type | NONE))? RIGHT_PAREN + ; + +drop_operator_family_statement + : OPERATOR FAMILY if_exists? schema_qualified_name USING identifier cascade_restrict? + ; + +create_operator_class_statement + : OPERATOR CLASS schema_qualified_name DEFAULT? FOR TYPE data_type + USING identifier (FAMILY schema_qualified_name)? AS + create_operator_class_option (COMMA create_operator_class_option)* + ; + +create_operator_class_option + : OPERATOR unsigned_numeric_literal name=operator_name + (LEFT_PAREN (data_type | NONE) COMMA (data_type | NONE) RIGHT_PAREN)? + (FOR SEARCH | FOR ORDER BY schema_qualified_name)? + | FUNCTION unsigned_numeric_literal + (LEFT_PAREN (data_type | NONE) (COMMA (data_type | NONE))? RIGHT_PAREN)? + function_call + | STORAGE data_type + ; + +alter_operator_class_statement + : OPERATOR CLASS schema_qualified_name USING identifier (rename_to | owner_to | set_schema) + ; + +drop_operator_class_statement + : OPERATOR CLASS if_exists? schema_qualified_name USING identifier cascade_restrict? + ; + +create_conversion_statement + : DEFAULT? CONVERSION schema_qualified_name FOR Character_String_Literal TO Character_String_Literal FROM schema_qualified_name + ; + +alter_conversion_statement + : CONVERSION schema_qualified_name (rename_to | owner_to | set_schema) + ; + +create_publication_statement + : PUBLICATION identifier + (FOR TABLE only_table_multiply (COMMA only_table_multiply)* | FOR ALL TABLES)? + with_storage_parameter? + ; + +alter_publication_statement + : PUBLICATION identifier alter_publication_action + ; + +alter_publication_action + : rename_to + | owner_to + | SET storage_parameter + | (ADD | DROP | SET) TABLE only_table_multiply (COMMA only_table_multiply)* + ; + +only_table_multiply + : ONLY? schema_qualified_name MULTIPLY? + ; + +alter_trigger_statement + : TRIGGER identifier ON schema_qualified_name (rename_to | DEPENDS ON EXTENSION identifier) + ; + +alter_rule_statement + : RULE identifier ON schema_qualified_name rename_to + ; + +copy_statement + : copy_to_statement + | copy_from_statement + ; + +copy_from_statement + : COPY table_cols + FROM (PROGRAM? Character_String_Literal | STDIN) + (WITH? (LEFT_PAREN copy_option_list RIGHT_PAREN | copy_option_list))? + (WHERE vex)? + ; + +copy_to_statement + : COPY (table_cols | LEFT_PAREN data_statement RIGHT_PAREN) + TO (PROGRAM? Character_String_Literal | STDOUT) + (WITH? (LEFT_PAREN copy_option_list RIGHT_PAREN | copy_option_list))? + ; + +copy_option_list + : copy_option (COMMA? copy_option)* + ; + +copy_option + : FORMAT? (TEXT | CSV | BINARY) + | OIDS truth_value? + | FREEZE truth_value? + | DELIMITER AS? Character_String_Literal + | NULL AS? Character_String_Literal + | HEADER truth_value? + | QUOTE Character_String_Literal + | ESCAPE Character_String_Literal + | FORCE QUOTE (MULTIPLY | identifier_list) + | FORCE_QUOTE (MULTIPLY | LEFT_PAREN identifier_list RIGHT_PAREN) + | FORCE NOT NULL identifier_list + | FORCE_NOT_NULL LEFT_PAREN identifier_list RIGHT_PAREN + | FORCE_NULL LEFT_PAREN identifier_list RIGHT_PAREN + | ENCODING Character_String_Literal + ; + +create_view_statement + : (OR REPLACE)? (TEMP | TEMPORARY)? RECURSIVE? MATERIALIZED? VIEW + if_not_exists? name=schema_qualified_name column_names=view_columns? + (USING identifier)? + (WITH storage_parameter)? + table_space? + AS v_query=select_stmt + with_check_option? + (WITH NO? DATA)? + ; + +if_exists + : IF EXISTS + ; + +if_not_exists + : IF NOT EXISTS + ; + +view_columns + : LEFT_PAREN identifier (COMMA identifier)* RIGHT_PAREN + ; + +with_check_option + : WITH (CASCADED|LOCAL)? CHECK OPTION + ; + +create_table_statement + : ((GLOBAL | LOCAL)? (TEMPORARY | TEMP) | UNLOGGED)? TABLE if_not_exists? name=schema_qualified_name + define_table + partition_by? + (USING identifier)? + storage_parameter_oid? + on_commit? + table_space? + ; + +create_table_as_statement + : ((GLOBAL | LOCAL)? (TEMPORARY | TEMP) | UNLOGGED)? TABLE if_not_exists? name=schema_qualified_name + names_in_parens? + (USING identifier)? + storage_parameter_oid? + on_commit? + table_space? + AS (select_stmt | EXECUTE function_call) + (WITH NO? DATA)? + ; + +create_foreign_table_statement + : FOREIGN TABLE if_not_exists? name=schema_qualified_name + (define_columns | define_partition) + define_server + ; + +define_table + : define_columns + | define_type + | define_partition + ; + +define_partition + : PARTITION OF parent_table=schema_qualified_name + list_of_type_column_def? + for_values_bound + ; + +for_values_bound + : FOR VALUES partition_bound_spec + | DEFAULT + ; + +partition_bound_spec + : IN LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN + | FROM partition_bound_part TO partition_bound_part + | WITH LEFT_PAREN MODULUS NUMBER_LITERAL COMMA REMAINDER NUMBER_LITERAL RIGHT_PAREN + ; + +partition_bound_part + : LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN + ; + +define_columns + : LEFT_PAREN (table_column_def (COMMA table_column_def)*)? RIGHT_PAREN (INHERITS names_in_parens)? + ; + +define_type + : OF type_name=data_type list_of_type_column_def? + ; + +partition_by + : PARTITION BY partition_method + ; + +partition_method + : (RANGE | LIST | HASH) LEFT_PAREN partition_column (COMMA partition_column)* RIGHT_PAREN + ; + +partition_column + : vex identifier? + ; + +define_server + : SERVER identifier define_foreign_options? + ; + +define_foreign_options + : OPTIONS LEFT_PAREN (foreign_option (COMMA foreign_option)*) RIGHT_PAREN + ; + +foreign_option + : (ADD | SET | DROP)? foreign_option_name character_string? + ; + +foreign_option_name + : identifier + | USER + ; + +list_of_type_column_def + : LEFT_PAREN (table_of_type_column_def (COMMA table_of_type_column_def)*) RIGHT_PAREN + ; + +table_column_def + : table_column_definition + | tabl_constraint=constraint_common + | LIKE schema_qualified_name like_option* + ; + +table_of_type_column_def + : identifier (WITH OPTIONS)? constraint_common* + | tabl_constraint=constraint_common + ; + +table_column_definition + : identifier data_type define_foreign_options? collate_identifier? constraint_common* + ; + +like_option + : (INCLUDING | EXCLUDING) (COMMENTS | CONSTRAINTS | DEFAULTS | GENERATED | IDENTITY | INDEXES | STORAGE | ALL) + ; +/** NULL, DEFAULT - column constraint +* EXCLUDE, FOREIGN KEY - table_constraint +*/ +constraint_common + : (CONSTRAINT identifier)? constr_body table_deferrable? table_initialy_immed? + ; + +constr_body + : EXCLUDE (USING index_method=identifier)? + LEFT_PAREN sort_specifier WITH all_op (COMMA sort_specifier WITH all_op)* RIGHT_PAREN + index_parameters (where=WHERE exp=vex)? + | (FOREIGN KEY names_in_parens)? REFERENCES schema_qualified_name ref=names_in_parens? + (MATCH (FULL | PARTIAL | SIMPLE) | ON (DELETE | UPDATE) action)* + | CHECK LEFT_PAREN expression=vex RIGHT_PAREN (NO INHERIT)? + | NOT? NULL + | (UNIQUE | PRIMARY KEY) col=names_in_parens? index_parameters + | DEFAULT default_expr=vex + | identity_body + | GENERATED ALWAYS AS LEFT_PAREN vex RIGHT_PAREN STORED + ; + +all_op + : op + | EQUAL | NOT_EQUAL | LTH | LEQ | GTH | GEQ + | PLUS | MINUS | MULTIPLY | DIVIDE | MODULAR | EXP + ; + +all_simple_op + : op_chars + | EQUAL | NOT_EQUAL | LTH | LEQ | GTH | GEQ + | PLUS | MINUS | MULTIPLY | DIVIDE | MODULAR | EXP + ; + +op_chars + : OP_CHARS + | LESS_LESS + | GREATER_GREATER + | HASH_SIGN + ; + +index_parameters + : including_index? with_storage_parameter? (USING INDEX (table_space | schema_qualified_name))? + ; + +names_in_parens + : LEFT_PAREN names_references RIGHT_PAREN + ; + +names_references + : schema_qualified_name (COMMA schema_qualified_name)* + ; + +storage_parameter + : LEFT_PAREN storage_parameter_option (COMMA storage_parameter_option)* RIGHT_PAREN + ; + +storage_parameter_option + : storage_parameter_name (EQUAL vex)? + ; + +storage_parameter_name + : col_label (DOT col_label)? + ; + +with_storage_parameter + : WITH storage_parameter + ; + +storage_parameter_oid + : with_storage_parameter | (WITH OIDS) | (WITHOUT OIDS) + ; + +on_commit + : ON COMMIT (PRESERVE ROWS | DELETE ROWS | DROP) + ; + +table_space + : TABLESPACE identifier + ; + +action + : cascade_restrict + | SET (NULL | DEFAULT) + | NO ACTION + ; + +owner_to + : OWNER TO (name=identifier | CURRENT_USER | SESSION_USER) + ; + +rename_to + : RENAME TO name=identifier + ; + +set_schema + : SET SCHEMA identifier + ; + +table_column_privilege + : SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER | ALL PRIVILEGES? + ; + +usage_select_update + : USAGE | SELECT | UPDATE + ; + +partition_by_columns + : PARTITION BY vex (COMMA vex)* + ; + +cascade_restrict + : CASCADE | RESTRICT + ; + +collate_identifier + : COLLATE collation=schema_qualified_name + ; + +indirection_var + : (identifier | dollar_number) indirection_list? + ; + +dollar_number + : DOLLAR_NUMBER + ; + +indirection_list + : indirection+ + | indirection* DOT MULTIPLY + ; + +indirection + : DOT col_label + | LEFT_BRACKET vex RIGHT_BRACKET + | LEFT_BRACKET vex? COLON vex? RIGHT_BRACKET + ; + +/* +=============================================================================== + 11.21 +=============================================================================== +*/ + +drop_function_statement + : (FUNCTION | PROCEDURE | AGGREGATE) if_exists? name=schema_qualified_name function_args? cascade_restrict? + ; + +drop_trigger_statement + : TRIGGER if_exists? name=identifier ON table_name=schema_qualified_name cascade_restrict? + ; + +drop_rule_statement + : RULE if_exists? name=identifier ON schema_qualified_name cascade_restrict? + ; + +drop_statements + : (ACCESS METHOD + | COLLATION + | CONVERSION + | DATABASE + | DOMAIN + | EVENT TRIGGER + | EXTENSION + | GROUP + | FOREIGN? TABLE + | FOREIGN DATA WRAPPER + | INDEX CONCURRENTLY? + | MATERIALIZED? VIEW + | PROCEDURAL? LANGUAGE + | PUBLICATION + | ROLE + | SCHEMA + | SEQUENCE + | SERVER + | STATISTICS + | SUBSCRIPTION + | TABLESPACE + | TYPE + | TEXT SEARCH (CONFIGURATION | DICTIONARY | PARSER | TEMPLATE) + | USER) if_exist_names_restrict_cascade + ; + +if_exist_names_restrict_cascade + : if_exists? names_references cascade_restrict? + ; +/* +=============================================================================== + 5.2 + + Specifying lexical units (tokens and separators) that participate in SQL language +=============================================================================== +*/ + +id_token + : Identifier | QuotedIdentifier | tokens_nonkeyword; + +/* + old rule for default old identifier behavior + includes types +*/ +identifier + : id_token + | tokens_nonreserved + | tokens_nonreserved_except_function_type + ; + +identifier_nontype + : id_token + | tokens_nonreserved + | tokens_reserved_except_function_type + ; + +col_label + : id_token + | tokens_reserved + | tokens_nonreserved + | tokens_reserved_except_function_type + | tokens_nonreserved_except_function_type + ; + +/* + * These rules should be generated using code in the Keyword class. + * Word tokens that are not keywords should be added to nonreserved list. + */ +tokens_nonreserved + : ABORT + | ABSOLUTE + | ACCESS + | ACTION + | ADD + | ADMIN + | AFTER + | AGGREGATE + | ALSO + | ALTER + | ALWAYS + | ASSERTION + | ASSIGNMENT + | AT + | ATTACH + | ATTRIBUTE + | BACKWARD + | BEFORE + | BEGIN + | BY + | CACHE + | CALL + | CALLED + | CASCADE + | CASCADED + | CATALOG + | CHAIN + | CHARACTERISTICS + | CHECKPOINT + | CLASS + | CLOSE + | CLUSTER + | COLUMNS + | COMMENT + | COMMENTS + | COMMIT + | COMMITTED + | CONFIGURATION + | CONFLICT + | CONNECTION + | CONSTRAINTS + | CONTENT + | CONTINUE + | CONVERSION + | COPY + | COST + | CSV + | CUBE + | CURRENT + | CURSOR + | CYCLE + | DATA + | DATABASE + | DAY + | DEALLOCATE + | DECLARE + | DEFAULTS + | DEFERRED + | DEFINER + | DELETE + | DELIMITER + | DELIMITERS + | DEPENDS + | DETACH + | DICTIONARY + | DISABLE + | DISCARD + | DOCUMENT + | DOMAIN + | DOUBLE + | DROP + | EACH + | ENABLE + | ENCODING + | ENCRYPTED + | ENUM + | ESCAPE + | EVENT + | EXCLUDE + | EXCLUDING + | EXCLUSIVE + | EXECUTE + | EXPLAIN + | EXTENSION + | EXTERNAL + | FAMILY + | FILTER + | FIRST + | FOLLOWING + | FORCE + | FORWARD + | FUNCTION + | FUNCTIONS + | GENERATED + | GLOBAL + | GRANTED + | GROUPS + | HANDLER + | HEADER + | HOLD + | HOUR + | IDENTITY + | IF + | IMMEDIATE + | IMMUTABLE + | IMPLICIT + | IMPORT + | INCLUDE + | INCLUDING + | INCREMENT + | INDEX + | INDEXES + | INHERIT + | INHERITS + | INLINE + | INPUT + | INSENSITIVE + | INSERT + | INSTEAD + | INVOKER + | ISOLATION + | KEY + | LABEL + | LANGUAGE + | LARGE + | LAST + | LEAKPROOF + | LEVEL + | LISTEN + | LOAD + | LOCAL + | LOCATION + | LOCK + | LOCKED + | LOGGED + | MAPPING + | MATCH + | MATERIALIZED + | MAXVALUE + | METHOD + | MINUTE + | MINVALUE + | MODE + | MONTH + | MOVE + | NAME + | NAMES + | NEW + | NEXT + | NO + | NOTHING + | NOTIFY + | NOWAIT + | NULLS + | OBJECT + | 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 + | RELEASE + | RENAME + | REPEATABLE + | REPLACE + | REPLICA + | RESET + | RESTART + | RESTRICT + | RETURNS + | REVOKE + | ROLE + | ROLLBACK + | ROLLUP + | ROUTINE + | ROUTINES + | ROWS + | RULE + | SAVEPOINT + | SCHEMA + | SCHEMAS + | SCROLL + | SEARCH + | SECOND + | SECURITY + | SEQUENCE + | SEQUENCES + | SERIALIZABLE + | SERVER + | SESSION + | SET + | SETS + | SHARE + | SHOW + | SIMPLE + | SKIP_ + | SNAPSHOT + | SQL + | STABLE + | STANDALONE + | START + | STATEMENT + | STATISTICS + | STDIN + | STDOUT + | STORAGE + | STORED + | STRICT + | STRIP + | SUBSCRIPTION + | SUPPORT + | SYSID + | SYSTEM + | TABLES + | TABLESPACE + | TEMP + | TEMPLATE + | TEMPORARY + | TEXT + | TIES + | TRANSACTION + | TRANSFORM + | TRIGGER + | TRUNCATE + | TRUSTED + | TYPE + | TYPES + | UNBOUNDED + | UNCOMMITTED + | UNENCRYPTED + | UNKNOWN + | UNLISTEN + | UNLOGGED + | UNTIL + | UPDATE + | VACUUM + | VALID + | VALIDATE + | VALIDATOR + | VALUE + | VARYING + | VERSION + | VIEW + | VIEWS + | VOLATILE + | WHITESPACE + | WITHIN + | WITHOUT + | WORK + | WRAPPER + | WRITE + | XML + | YEAR + | YES + | ZONE + ; + +tokens_nonreserved_except_function_type + : BETWEEN + | BIGINT + | BIT + | BOOLEAN + | CHAR + | CHARACTER + | COALESCE + | DEC + | DECIMAL + | EXISTS + | EXTRACT + | FLOAT + | GREATEST + | GROUPING + | INOUT + | INT + | INTEGER + | INTERVAL + | LEAST + | NATIONAL + | NCHAR + | NONE + | NULLIF + | NUMERIC + | OUT + | 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 + ; + +tokens_reserved_except_function_type + : AUTHORIZATION + | BINARY + | COLLATION + | CONCURRENTLY + | CROSS + | CURRENT_SCHEMA + | FREEZE + | FULL + | ILIKE + | INNER + | IS + | ISNULL + | JOIN + | LEFT + | LIKE + | NATURAL + | NOTNULL + | OUTER + | OVERLAPS + | RIGHT + | SIMILAR + | TABLESAMPLE + | VERBOSE + ; + +tokens_reserved + : 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 + | EXCEPT + | FALSE + | FETCH + | FOR + | FOREIGN + | FROM + | GRANT + | GROUP + | HAVING + | IN + | INITIALLY + | INTERSECT + | INTO + | LATERAL + | LEADING + | LIMIT + | LOCALTIME + | LOCALTIMESTAMP + | NOT + | NULL + | OFFSET + | ON + | ONLY + | OR + | ORDER + | PLACING + | PRIMARY + | REFERENCES + | RETURNING + | SELECT + | SESSION_USER + | SOME + | SYMMETRIC + | TABLE + | THEN + | TO + | TRAILING + | TRUE + | UNION + | UNIQUE + | USER + | USING + | VARIADIC + | WHEN + | WHERE + | WINDOW + | WITH + ; + +tokens_nonkeyword + : ALIGNMENT + | BASETYPE + | BUFFERS + | BYPASSRLS + | CANONICAL + | CATEGORY + | COLLATABLE + | COMBINEFUNC + | COMMUTATOR + | CONNECT + | COSTS + | CREATEDB + | CREATEROLE + | DESERIALFUNC + | DETERMINISTIC + | DISABLE_PAGE_SKIPPING + | ELEMENT + | EXTENDED + | FINALFUNC + | FINALFUNC_EXTRA + | FINALFUNC_MODIFY + | FORCE_NOT_NULL + | FORCE_NULL + | FORCE_QUOTE + | FORMAT + | GETTOKEN + | HASH + | HASHES + | HEADLINE + | HYPOTHETICAL + | INDEX_CLEANUP + | INIT + | INITCOND + | INTERNALLENGTH + | JSON + | LC_COLLATE + | LC_CTYPE + | LEFTARG + | LEXIZE + | LEXTYPES + | LIST + | LOCALE + | LOGIN + | MAIN + | MERGES + | MFINALFUNC + | MFINALFUNC_EXTRA + | MFINALFUNC_MODIFY + | MINITCOND + | MINVFUNC + | MODULUS + | MSFUNC + | MSSPACE + | MSTYPE + | NEGATOR + | NOBYPASSRLS + | NOCREATEDB + | NOCREATEROLE + | NOINHERIT + | NOLOGIN + | NOREPLICATION + | NOSUPERUSER + | OUTPUT + | PASSEDBYVALUE + | PATH + | PERMISSIVE + | PLAIN + | PREFERRED + | PROVIDER + | READ_ONLY + | READ_WRITE + | RECEIVE + | REPLICATION + | REMAINDER + | RESTRICTED + | RESTRICTIVE + | RIGHTARG + | SAFE + | SEND + | SERIALFUNC + | SETTINGS + | SFUNC + | SHAREABLE + | SKIP_LOCKED + | SORTOP + | SSPACE + | STYPE + | SUBTYPE + | SUBTYPE_DIFF + | SUBTYPE_OPCLASS + | SUMMARY + | SUPERUSER + | TIMING + | TYPMOD_IN + | TYPMOD_OUT + | UNSAFE + | USAGE + | VARIABLE + | YAML + + // plpgsql tokens + | ALIAS + | ASSERT + | CONSTANT + | DATATYPE + | DEBUG + | DETAIL + | DIAGNOSTICS + | ELSEIF + | ELSIF + | ERRCODE + | EXIT + | EXCEPTION + | FOREACH + | GET + | HINT + | INFO + | LOG + | LOOP + | MESSAGE + | NOTICE + | OPEN + | PERFORM + | QUERY + | RAISE + | RECORD + | RETURN + | REVERSE + | ROWTYPE + | SLICE + | SQLSTATE + | STACKED + | WARNING + | WHILE + ; + +/* +=============================================================================== + 6.1 +=============================================================================== +*/ + +schema_qualified_name_nontype + : identifier_nontype + | schema=identifier DOT identifier_nontype + ; + +type_list + : data_type (COMMA data_type)* + ; + +data_type + : SETOF? predefined_type (ARRAY array_type? | array_type+)? + ; + +array_type + : LEFT_BRACKET NUMBER_LITERAL? RIGHT_BRACKET + ; + +predefined_type + : BIGINT + | BIT VARYING? type_length? + | BOOLEAN + | DEC precision_param? + | DECIMAL precision_param? + | DOUBLE PRECISION + | FLOAT precision_param? + | INT + | INTEGER + | INTERVAL interval_field? type_length? + | NATIONAL? (CHARACTER | CHAR) VARYING? type_length? + | NCHAR VARYING? type_length? + | NUMERIC precision_param? + | REAL + | SMALLINT + | TIME type_length? ((WITH | WITHOUT) TIME ZONE)? + | TIMESTAMP type_length? ((WITH | WITHOUT) TIME ZONE)? + | VARCHAR type_length? + | schema_qualified_name_nontype (LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN)? + ; + +interval_field + : YEAR + | MONTH + | DAY + | HOUR + | MINUTE + | SECOND + | YEAR TO MONTH + | DAY TO HOUR + | DAY TO MINUTE + | DAY TO SECOND + | HOUR TO MINUTE + | HOUR TO SECOND + | MINUTE TO SECOND + ; + +type_length + : LEFT_PAREN NUMBER_LITERAL RIGHT_PAREN + ; + +precision_param + : LEFT_PAREN precision=NUMBER_LITERAL (COMMA scale=NUMBER_LITERAL)? RIGHT_PAREN + ; + +/* +=============================================================================== + 6.25 +=============================================================================== +*/ + +vex + : vex CAST_EXPRESSION data_type + | LEFT_PAREN vex RIGHT_PAREN indirection_list? + | LEFT_PAREN vex (COMMA vex)+ RIGHT_PAREN + | vex collate_identifier + | (PLUS | MINUS) vex + | vex AT TIME ZONE vex + | vex EXP vex + | vex (MULTIPLY | DIVIDE | MODULAR) vex + | vex (PLUS | MINUS) vex + // TODO a lot of ambiguities between 3 next alternatives + | vex op vex + | op vex + | vex op + | vex NOT? IN LEFT_PAREN (select_stmt_no_parens | vex (COMMA vex)*) RIGHT_PAREN + | vex NOT? BETWEEN (ASYMMETRIC | SYMMETRIC)? vex_b AND vex + | vex NOT? (LIKE | ILIKE | SIMILAR TO) vex + | vex NOT? (LIKE | ILIKE | SIMILAR TO) vex ESCAPE vex + | vex (LTH | GTH | LEQ | GEQ | EQUAL | NOT_EQUAL) vex + | vex IS NOT? (truth_value | NULL) + | vex IS NOT? DISTINCT FROM vex + | vex IS NOT? DOCUMENT + | vex IS NOT? UNKNOWN + | vex IS NOT? OF LEFT_PAREN type_list RIGHT_PAREN + | vex ISNULL + | vex NOTNULL + | NOT vex + | vex AND vex + | vex OR vex + | value_expression_primary + ; + +// partial copy of vex +// resolves (vex BETWEEN vex AND vex) vs. (vex AND vex) ambiguity +// vex references that are not at alternative edge are referencing the full rule +// see postgres' b_expr (src/backend/parser/gram.y) +vex_b + : vex_b CAST_EXPRESSION data_type + | LEFT_PAREN vex RIGHT_PAREN indirection_list? + | LEFT_PAREN vex (COMMA vex)+ RIGHT_PAREN + | (PLUS | MINUS) vex_b + | vex_b EXP vex_b + | vex_b (MULTIPLY | DIVIDE | MODULAR) vex_b + | vex_b (PLUS | MINUS) vex_b + | vex_b op vex_b + | op vex_b + | vex_b op + | vex_b (LTH | GTH | LEQ | GEQ | EQUAL | NOT_EQUAL) vex_b + | vex_b IS NOT? DISTINCT FROM vex_b + | vex_b IS NOT? DOCUMENT + | vex_b IS NOT? UNKNOWN + | vex_b IS NOT? OF LEFT_PAREN type_list RIGHT_PAREN + | value_expression_primary + ; + +op + : op_chars + | OPERATOR LEFT_PAREN identifier DOT all_simple_op RIGHT_PAREN + ; + +all_op_ref + : all_simple_op + | OPERATOR LEFT_PAREN identifier DOT all_simple_op RIGHT_PAREN + ; + +datetime_overlaps + : LEFT_PAREN vex COMMA vex RIGHT_PAREN OVERLAPS LEFT_PAREN vex COMMA vex RIGHT_PAREN + ; + +value_expression_primary + : unsigned_value_specification + | LEFT_PAREN select_stmt_no_parens RIGHT_PAREN indirection_list? + | case_expression + | NULL + | MULTIPLY + // technically incorrect since ANY cannot be value expression + // but fixing this would require to write a vex rule duplicating all operators + // like vex (op|op|op|...) comparison_mod + | comparison_mod + | EXISTS table_subquery + | function_call + | indirection_var + | array_expression + | type_coercion + | datetime_overlaps + ; + +unsigned_value_specification + : unsigned_numeric_literal + | character_string + | truth_value + ; + +unsigned_numeric_literal + : NUMBER_LITERAL + | REAL_NUMBER + ; + +truth_value + : TRUE | FALSE | ON // on is reserved but is required by SET statements + ; + +case_expression + : CASE vex? (WHEN vex THEN r+=vex)+ (ELSE r+=vex)? END + ; + +cast_specification + : (CAST | TREAT) LEFT_PAREN vex AS data_type RIGHT_PAREN + ; + +// using data_type for function name because keyword-named functions +// use the same category of keywords as keyword-named types +function_call + : schema_qualified_name_nontype LEFT_PAREN (set_qualifier? vex_or_named_notation (COMMA vex_or_named_notation)* orderby_clause?)? RIGHT_PAREN + (WITHIN GROUP LEFT_PAREN orderby_clause RIGHT_PAREN)? + filter_clause? (OVER (identifier | window_definition))? + | function_construct + | extract_function + | system_function + | date_time_function + | string_value_function + | xml_function + ; + +vex_or_named_notation + : VARIADIC? (argname=identifier pointer)? vex + ; + +pointer + : EQUAL_GTH | COLON_EQUAL + ; + +function_construct + : (COALESCE | GREATEST | GROUPING | LEAST | NULLIF | XMLCONCAT) LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN + | ROW LEFT_PAREN (vex (COMMA vex)*)? RIGHT_PAREN + ; + +extract_function + : EXTRACT LEFT_PAREN (identifier | character_string) FROM vex RIGHT_PAREN + ; + +system_function + : CURRENT_CATALOG + // parens are handled by generic function call + // since current_schema is defined as reserved(can be function) keyword + | CURRENT_SCHEMA /*(LEFT_PAREN RIGHT_PAREN)?*/ + | CURRENT_USER + | SESSION_USER + | USER + | cast_specification + ; + +date_time_function + : CURRENT_DATE + | CURRENT_TIME type_length? + | CURRENT_TIMESTAMP type_length? + | LOCALTIME type_length? + | LOCALTIMESTAMP type_length? + ; + +string_value_function + : TRIM LEFT_PAREN (LEADING | TRAILING | BOTH)? (chars=vex FROM str=vex | FROM? str=vex (COMMA chars=vex)?) RIGHT_PAREN + | SUBSTRING LEFT_PAREN vex (COMMA vex)* (FROM vex)? (FOR vex)? RIGHT_PAREN + | POSITION LEFT_PAREN vex_b IN vex RIGHT_PAREN + | OVERLAY LEFT_PAREN vex PLACING vex FROM vex (FOR vex)? RIGHT_PAREN + | COLLATION FOR LEFT_PAREN vex RIGHT_PAREN + ; + +xml_function + : XMLELEMENT LEFT_PAREN NAME name=identifier + (COMMA XMLATTRIBUTES LEFT_PAREN vex (AS attname=identifier)? (COMMA vex (AS attname=identifier)?)* RIGHT_PAREN)? + (COMMA vex)* RIGHT_PAREN + | XMLFOREST LEFT_PAREN vex (AS name=identifier)? (COMMA vex (AS name=identifier)?)* RIGHT_PAREN + | XMLPI LEFT_PAREN NAME name=identifier (COMMA vex)? RIGHT_PAREN + | XMLROOT LEFT_PAREN vex COMMA VERSION (vex | NO VALUE) (COMMA STANDALONE (YES | NO | NO VALUE))? RIGHT_PAREN + | XMLEXISTS LEFT_PAREN vex PASSING (BY REF)? vex (BY REF)? RIGHT_PAREN + | XMLPARSE LEFT_PAREN (DOCUMENT | CONTENT) vex RIGHT_PAREN + | XMLSERIALIZE LEFT_PAREN (DOCUMENT | CONTENT) vex AS data_type RIGHT_PAREN + | XMLTABLE LEFT_PAREN + (XMLNAMESPACES LEFT_PAREN vex AS name=identifier (COMMA vex AS name=identifier)* RIGHT_PAREN COMMA)? + vex PASSING (BY REF)? vex (BY REF)? + COLUMNS xml_table_column (COMMA xml_table_column)* + RIGHT_PAREN + ; + +xml_table_column + : name=identifier (data_type (PATH vex)? (DEFAULT vex)? (NOT? NULL)? | FOR ORDINALITY) + ; + +comparison_mod + : (ALL | ANY | SOME) LEFT_PAREN (vex | select_stmt_no_parens) RIGHT_PAREN + ; + +filter_clause + : FILTER LEFT_PAREN WHERE vex RIGHT_PAREN + ; + +window_definition + : LEFT_PAREN identifier? partition_by_columns? orderby_clause? frame_clause? RIGHT_PAREN + ; + +frame_clause + : (RANGE | ROWS | GROUPS) (frame_bound | BETWEEN frame_bound AND frame_bound) + (EXCLUDE (CURRENT ROW | GROUP | TIES | NO OTHERS))? + ; + +frame_bound + : vex (PRECEDING | FOLLOWING) + | CURRENT ROW + ; + +array_expression + : ARRAY (array_elements | table_subquery) + ; + +array_elements + : LEFT_BRACKET ((vex | array_elements) (COMMA (vex | array_elements))*)? RIGHT_BRACKET + ; + +type_coercion + : data_type character_string + | INTERVAL character_string interval_field type_length? + ; + +/* +=============================================================================== + 7.13 +=============================================================================== +*/ +schema_qualified_name + : identifier ( DOT identifier ( DOT identifier )? )? + ; + +set_qualifier + : DISTINCT | ALL + ; + +table_subquery + : LEFT_PAREN select_stmt RIGHT_PAREN + ; + +select_stmt + : with_clause? select_ops after_ops* + ; + +after_ops + : orderby_clause + | LIMIT (vex | ALL) + | OFFSET vex (ROW | ROWS)? + | FETCH (FIRST | NEXT) vex? (ROW | ROWS) ONLY? + | FOR (UPDATE | NO KEY UPDATE | SHARE | KEY SHARE) (OF schema_qualified_name (COMMA schema_qualified_name)*)? (NOWAIT | SKIP_ LOCKED)? + ; + +// select_stmt copy that doesn't consume external parens +// for use in vex +// we let the vex rule to consume as many parens as it can +select_stmt_no_parens + : with_clause? select_ops_no_parens after_ops* + ; + +with_clause + : WITH RECURSIVE? with_query (COMMA with_query)* + ; + +with_query + : query_name=identifier (LEFT_PAREN column_name+=identifier (COMMA column_name+=identifier)* RIGHT_PAREN)? + AS (NOT? MATERIALIZED)? LEFT_PAREN data_statement RIGHT_PAREN + ; + +select_ops + : LEFT_PAREN select_stmt RIGHT_PAREN // parens can be used to apply "global" clauses (WITH etc) to a particular select in UNION expr + | select_ops (INTERSECT | UNION | EXCEPT) set_qualifier? select_ops + | select_primary + ; + +// version of select_ops for use in select_stmt_no_parens +select_ops_no_parens + : select_ops (INTERSECT | UNION | EXCEPT) set_qualifier? (select_primary | LEFT_PAREN select_stmt RIGHT_PAREN) + | select_primary + ; + +select_primary + : SELECT + (set_qualifier (ON LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN)?)? + select_list? into_table? + (FROM from_item (COMMA from_item)*)? + (WHERE vex)? + groupby_clause? + (HAVING vex)? + (WINDOW identifier AS window_definition (COMMA identifier AS window_definition)*)? + | TABLE ONLY? schema_qualified_name MULTIPLY? + | values_stmt + ; + +select_list + : select_sublist (COMMA select_sublist)* + ; + +select_sublist + : vex (AS col_label | id_token)? + ; + +into_table + : INTO (TEMPORARY | TEMP | UNLOGGED)? TABLE? schema_qualified_name + ; + +from_item + : LEFT_PAREN from_item RIGHT_PAREN alias_clause? + | from_item CROSS JOIN from_item + | from_item (INNER | (LEFT | RIGHT | FULL) OUTER?)? JOIN from_item ON vex + | from_item (INNER | (LEFT | RIGHT | FULL) OUTER?)? JOIN from_item USING names_in_parens + | from_item NATURAL (INNER | (LEFT | RIGHT | FULL) OUTER?)? JOIN from_item + | from_primary + ; + +from_primary + : ONLY? schema_qualified_name MULTIPLY? alias_clause? (TABLESAMPLE method=identifier LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN (REPEATABLE vex)?)? + | LATERAL? table_subquery alias_clause + | LATERAL? function_call (WITH ORDINALITY)? + (AS from_function_column_def + | AS? alias=identifier (LEFT_PAREN column_alias+=identifier (COMMA column_alias+=identifier)* RIGHT_PAREN | from_function_column_def)? + )? + | LATERAL? ROWS FROM LEFT_PAREN function_call (AS from_function_column_def)? (COMMA function_call (AS from_function_column_def)?)* RIGHT_PAREN + (WITH ORDINALITY)? (AS? alias=identifier (LEFT_PAREN column_alias+=identifier (COMMA column_alias+=identifier)* RIGHT_PAREN)?)? + ; + +alias_clause + : AS? alias=identifier (LEFT_PAREN column_alias+=identifier (COMMA column_alias+=identifier)* RIGHT_PAREN)? + ; + +from_function_column_def + : LEFT_PAREN column_alias+=identifier data_type (COMMA column_alias+=identifier data_type)* RIGHT_PAREN + ; + +groupby_clause + : GROUP BY grouping_element_list + ; + +grouping_element_list + : grouping_element (COMMA grouping_element)* + ; + +grouping_element + : vex + | LEFT_PAREN RIGHT_PAREN + | (ROLLUP | CUBE | GROUPING SETS) LEFT_PAREN grouping_element_list RIGHT_PAREN + ; + +values_stmt + : VALUES values_values (COMMA values_values)* + ; + +values_values + : LEFT_PAREN (vex | DEFAULT) (COMMA (vex | DEFAULT))* RIGHT_PAREN + ; + +orderby_clause + : ORDER BY sort_specifier_list + ; + +sort_specifier_list + : sort_specifier (COMMA sort_specifier)* + ; + +sort_specifier + : key=vex + opclass=schema_qualified_name? // this allows to share this rule with create_index; technically invalid syntax + order=order_specification? + null_order=null_ordering? + ; + +order_specification + : ASC | DESC | USING all_op_ref + ; + +null_ordering + : NULLS (FIRST | LAST) + ; + +insert_stmt_for_psql + : with_clause? INSERT INTO insert_table_name=schema_qualified_name (AS alias=identifier)? + (OVERRIDING (SYSTEM | USER) VALUE)? insert_columns? + (select_stmt | DEFAULT VALUES) + (ON CONFLICT conflict_object? conflict_action)? + (RETURNING select_list)? + ; + +insert_columns + : LEFT_PAREN indirection_identifier (COMMA indirection_identifier)* RIGHT_PAREN + ; + +indirection_identifier + : identifier indirection_list? + ; + +conflict_object + : index_sort index_where? + | ON CONSTRAINT identifier + ; + +conflict_action + : DO NOTHING + | DO UPDATE SET update_set (COMMA update_set)* (WHERE vex)? + ; + +delete_stmt_for_psql + : with_clause? DELETE FROM ONLY? delete_table_name=schema_qualified_name MULTIPLY? (AS? alias=identifier)? + (USING from_item (COMMA from_item)*)? + (WHERE (vex | CURRENT OF cursor=identifier))? + (RETURNING select_list)? + ; + +update_stmt_for_psql + : with_clause? UPDATE ONLY? update_table_name=schema_qualified_name MULTIPLY? (AS? alias=identifier)? + SET update_set (COMMA update_set)* + (FROM from_item (COMMA from_item)*)? + (WHERE (vex | CURRENT OF cursor=identifier))? + (RETURNING select_list)? + ; + +update_set + : column+=indirection_identifier EQUAL (value+=vex | DEFAULT) + | LEFT_PAREN column+=indirection_identifier (COMMA column+=indirection_identifier)* RIGHT_PAREN EQUAL ROW? + (LEFT_PAREN (value+=vex | DEFAULT) (COMMA (value+=vex | DEFAULT))* RIGHT_PAREN | table_subquery) + ; + +notify_stmt + : NOTIFY channel=identifier (COMMA payload=character_string)? + ; + +truncate_stmt + : TRUNCATE TABLE? only_table_multiply (COMMA only_table_multiply)* + ((RESTART | CONTINUE) IDENTITY)? cascade_restrict? + ; + +identifier_list + : identifier (COMMA identifier)* + ; + +anonymous_block + : DO (LANGUAGE (identifier | character_string))? character_string + | DO character_string LANGUAGE (identifier | character_string) + ; + +// plpgsql rules + +comp_options + : HASH_SIGN identifier (identifier | truth_value) + ; + +function_block + : start_label? declarations? + BEGIN function_statements exception_statement? + END end_label=identifier? + ; + +start_label + : LESS_LESS identifier GREATER_GREATER + ; + +declarations + : DECLARE declaration* + ; + +declaration + : DECLARE* identifier type_declaration SEMI_COLON + ; + +type_declaration + : CONSTANT? data_type_dec collate_identifier? (NOT NULL)? ((DEFAULT | COLON_EQUAL | EQUAL) vex)? + | ALIAS FOR (identifier | DOLLAR_NUMBER) + | (NO? SCROLL)? CURSOR (LEFT_PAREN arguments_list RIGHT_PAREN)? (FOR | IS) select_stmt + ; + +arguments_list + : identifier data_type (COMMA identifier data_type)* + ; + +data_type_dec + : data_type + | schema_qualified_name MODULAR TYPE + | schema_qualified_name_nontype MODULAR ROWTYPE + ; + +exception_statement + : EXCEPTION (WHEN vex THEN function_statements)+ + ; + +function_statements + : (function_statement SEMI_COLON)* + ; + +function_statement + : function_block + | base_statement + | control_statement + | transaction_statement + | cursor_statement + | message_statement + | schema_statement + | plpgsql_query + | additional_statement + ; + +base_statement + : assign_stmt + | PERFORM perform_stmt + | GET (CURRENT | STACKED)? DIAGNOSTICS diagnostic_option (COMMA diagnostic_option)* + | NULL + ; + +var + : (schema_qualified_name | DOLLAR_NUMBER) (LEFT_BRACKET vex RIGHT_BRACKET)* + ; + +diagnostic_option + : var (COLON_EQUAL | EQUAL) identifier + ; + +// keep this in sync with select_primary (except intended differences) +perform_stmt + : (set_qualifier (ON LEFT_PAREN vex (COMMA vex)* RIGHT_PAREN)?)? + select_list + (FROM from_item (COMMA from_item)*)? + (WHERE vex)? + groupby_clause? + (HAVING vex)? + (WINDOW identifier AS window_definition (COMMA identifier AS window_definition)*)? + ((INTERSECT | UNION | EXCEPT) set_qualifier? select_ops)? + after_ops* + ; + +assign_stmt + : var (COLON_EQUAL | EQUAL) (select_stmt_no_parens | perform_stmt) + ; + +execute_stmt + : EXECUTE vex using_vex? + ; + +control_statement + : return_stmt + | CALL function_call + | if_statement + | case_statement + | loop_statement + ; + +cursor_statement + : OPEN var (NO? SCROLL)? FOR plpgsql_query + | OPEN var (LEFT_PAREN option (COMMA option)* RIGHT_PAREN)? + | FETCH fetch_move_direction? (FROM | IN)? var + | MOVE fetch_move_direction? (FROM | IN)? var + | CLOSE var + ; + +option + : (identifier COLON_EQUAL)? vex + ; + +transaction_statement + : (COMMIT | ROLLBACK) (AND NO? CHAIN)? + | lock_table + ; + +message_statement + : RAISE log_level? (character_string (COMMA vex)*)? raise_using? + | RAISE log_level? identifier raise_using? + | RAISE log_level? SQLSTATE character_string raise_using? + | ASSERT vex (COMMA vex)? + ; + +log_level + : DEBUG + | LOG + | INFO + | NOTICE + | WARNING + | EXCEPTION + ; + +raise_using + : USING raise_param EQUAL vex (COMMA raise_param EQUAL vex)* + ; + +raise_param + : MESSAGE + | DETAIL + | HINT + | ERRCODE + | COLUMN + | CONSTRAINT + | DATATYPE + | TABLE + | SCHEMA + ; + +return_stmt + : RETURN perform_stmt? + | RETURN NEXT vex + | RETURN QUERY plpgsql_query + ; + +loop_statement + : start_label? loop_start? LOOP function_statements END LOOP identifier? + | (EXIT | CONTINUE) identifier? (WHEN vex)? + ; + +loop_start + : WHILE vex + | FOR alias=identifier IN REVERSE? vex DOUBLE_DOT vex (BY vex)? + | FOR identifier_list IN plpgsql_query + | FOR cursor=identifier IN identifier (LEFT_PAREN option (COMMA option)* RIGHT_PAREN)? // cursor loop + | FOREACH identifier_list (SLICE NUMBER_LITERAL)? IN ARRAY vex + ; + +using_vex + : USING vex (COMMA vex)* + ; + +if_statement + : IF vex THEN function_statements ((ELSIF | ELSEIF) vex THEN function_statements)* (ELSE function_statements)? END IF + ; + +// plpgsql case +case_statement + : CASE vex? (WHEN vex (COMMA vex)* THEN function_statements)+ (ELSE function_statements)? END CASE + ; + +plpgsql_query + : data_statement + | execute_stmt + | show_statement + | explain_statement + ; diff --git a/sql_to_code/parsers/generated/PLpgSQLParser.interp b/sql_to_code/parsers/generated/PLpgSQLParser.interp new file mode 100644 index 0000000..3312cba --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLParser.interp @@ -0,0 +1,1635 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'=' +':' +';' +',' +null +'<' +'<=' +'>' +'>=' +'(' +')' +'+' +'-' +'*' +'/' +'%' +'^' +'.' +'\'' +'"' +'$' +'[' +']' +'=>' +':=' +'<<' +'>>' +'..' +'#' +null +null +null +null +null +null +null +null +null +null +' ' +null +null +'\u0009' +'\ufeff' +null +null +null + +token symbolic names: +null +ABORT +ABSOLUTE +ACCESS +ACTION +ADD +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTACH +ATTRIBUTE +BACKWARD +BEFORE +BEGIN +BY +CACHE +CALL +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COLUMNS +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONFLICT +CONNECTION +CONSTRAINTS +CONTENT +CONTINUE +CONVERSION +COPY +COST +CSV +CUBE +CURRENT +CURSOR +CYCLE +DATA +DATABASE +DAY +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE +DELIMITER +DELIMITERS +DEPENDS +DETACH +DICTIONARY +DISABLE +DISCARD +DOCUMENT +DOMAIN +DOUBLE +DROP +EACH +ENABLE +ENCODING +ENCRYPTED +ENUM +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FILTER +FIRST +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GENERATED +GLOBAL +GRANTED +GROUPS +HANDLER +HEADER +HOLD +HOUR +IDENTITY +IF +IMMEDIATE +IMMUTABLE +IMPLICIT +IMPORT +INCLUDE +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE +INPUT +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE +LAST +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK +LOCKED +LOGGED +MAPPING +MATCH +MATERIALIZED +MAXVALUE +METHOD +MINUTE +MINVALUE +MODE +MONTH +MOVE +NAME +NAMES +NEW +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS +OBJECT +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 +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROLLUP +ROUTINE +ROUTINES +ROWS +RULE +SAVEPOINT +SCHEMA +SCHEMAS +SCROLL +SEARCH +SECOND +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SETS +SHARE +SHOW +SIMPLE +SKIP_ +SNAPSHOT +SQL +STABLE +STANDALONE +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STORED +STRICT +STRIP +SUBSCRIPTION +SUPPORT +SYSID +SYSTEM +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT +TIES +TRANSACTION +TRANSFORM +TRIGGER +TRUNCATE +TRUSTED +TYPE +TYPES +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VALUE +VARYING +VERSION +VIEW +VIEWS +VOLATILE +WHITESPACE +WITHIN +WITHOUT +WORK +WRAPPER +WRITE +XML +YEAR +YES +ZONE +BETWEEN +BIGINT +BIT +BOOLEAN +CHAR +CHARACTER +COALESCE +DEC +DECIMAL +EXISTS +EXTRACT +FLOAT +GREATEST +GROUPING +INOUT +INT +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OUT +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 +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER +OVERLAPS +RIGHT +SIMILAR +TABLESAMPLE +VERBOSE +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 +EXCEPT +FALSE +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP +HAVING +IN +INITIALLY +INTERSECT +INTO +LATERAL +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +ALIGNMENT +BASETYPE +BUFFERS +BYPASSRLS +CANONICAL +CATEGORY +COLLATABLE +COMBINEFUNC +COMMUTATOR +CONNECT +COSTS +CREATEDB +CREATEROLE +DESERIALFUNC +DETERMINISTIC +DISABLE_PAGE_SKIPPING +ELEMENT +EXTENDED +FINALFUNC +FINALFUNC_EXTRA +FINALFUNC_MODIFY +FORCE_NOT_NULL +FORCE_NULL +FORCE_QUOTE +FORMAT +GETTOKEN +HASH +HASHES +HEADLINE +HYPOTHETICAL +INDEX_CLEANUP +INIT +INITCOND +INTERNALLENGTH +JSON +LC_COLLATE +LC_CTYPE +LEFTARG +LEXIZE +LEXTYPES +LIST +LOCALE +LOGIN +MAIN +MERGES +MFINALFUNC +MFINALFUNC_EXTRA +MFINALFUNC_MODIFY +MINITCOND +MINVFUNC +MODULUS +MSFUNC +MSSPACE +MSTYPE +NEGATOR +NOBYPASSRLS +NOCREATEDB +NOCREATEROLE +NOINHERIT +NOLOGIN +NOREPLICATION +NOSUPERUSER +OUTPUT +PASSEDBYVALUE +PATH +PERMISSIVE +PLAIN +PREFERRED +PROVIDER +READ_ONLY +READ_WRITE +RECEIVE +REMAINDER +REPLICATION +RESTRICTED +RESTRICTIVE +RIGHTARG +SAFE +SEND +SERIALFUNC +SETTINGS +SFUNC +SHAREABLE +SKIP_LOCKED +SORTOP +SSPACE +STYPE +SUBTYPE_DIFF +SUBTYPE_OPCLASS +SUBTYPE +SUMMARY +SUPERUSER +TIMING +TYPMOD_IN +TYPMOD_OUT +UNSAFE +USAGE +VARIABLE +YAML +ALIAS +ASSERT +CONSTANT +DATATYPE +DEBUG +DETAIL +DIAGNOSTICS +ELSEIF +ELSIF +ERRCODE +EXIT +EXCEPTION +FOREACH +GET +HINT +INFO +LOG +LOOP +MESSAGE +NOTICE +OPEN +PERFORM +QUERY +RAISE +RECORD +RETURN +REVERSE +ROWTYPE +SLICE +SQLSTATE +STACKED +WARNING +WHILE +CAST_EXPRESSION +EQUAL +COLON +SEMI_COLON +COMMA +NOT_EQUAL +LTH +LEQ +GTH +GEQ +LEFT_PAREN +RIGHT_PAREN +PLUS +MINUS +MULTIPLY +DIVIDE +MODULAR +EXP +DOT +QUOTE_CHAR +DOUBLE_QUOTE +DOLLAR +LEFT_BRACKET +RIGHT_BRACKET +EQUAL_GTH +COLON_EQUAL +LESS_LESS +GREATER_GREATER +DOUBLE_DOT +HASH_SIGN +BlockComment +LineComment +OP_CHARS +NUMBER_LITERAL +REAL_NUMBER +DOLLAR_NUMBER +Identifier +QuotedIdentifier +Character_String_Literal +BeginDollarStringConstant +Space +White_Space +New_Line +Tab +BOM +BAD +Text_between_Dollar +EndDollarStringConstant + +rule names: +sql +qname_parser +function_args_parser +vex_eof +plpgsql_function +plpgsql_function_test_list +statement +data_statement +script_statement +script_transaction +transaction_mode +lock_table +lock_mode +script_additional +additional_statement +explain_statement +explain_query +execute_statement +declare_statement +show_statement +explain_option +user_name +table_cols_list +table_cols +vacuum_mode +vacuum_option +analyze_mode +boolean_value +fetch_move_direction +schema_statement +schema_create +schema_alter +schema_drop +schema_import +alter_function_statement +alter_aggregate_statement +alter_extension_statement +alter_extension_action +extension_member_object +alter_schema_statement +alter_language_statement +alter_table_statement +table_action +column_action +identity_body +alter_identity +storage_option +validate_constraint +drop_constraint +table_deferrable +table_initialy_immed +function_actions_common +function_def +alter_index_statement +index_def_action +alter_default_privileges +abbreviated_grant_or_revoke +grant_option_for +alter_sequence_statement +alter_view_statement +alter_event_trigger +alter_event_trigger_action +alter_type_statement +alter_domain_statement +alter_server_statement +alter_server_action +alter_fts_statement +alter_fts_configuration +type_action +set_def_column +drop_def +create_index_statement +index_rest +index_sort +including_index +index_where +create_extension_statement +create_language_statement +create_event_trigger +create_type_statement +create_domain_statement +create_server_statement +create_fts_dictionary +option_with_value +create_fts_configuration +create_fts_template +create_fts_parser +create_collation +alter_collation +collation_option +create_user_mapping +alter_user_mapping +alter_user_or_role +alter_user_or_role_set_reset +user_or_role_set_reset +alter_group +alter_group_action +alter_tablespace +alter_owner +alter_tablespace_action +alter_statistics +alter_foreign_data_wrapper +alter_foreign_data_wrapper_action +alter_operator_statement +alter_operator_action +operator_set_restrict_join +drop_user_mapping +drop_owned +drop_operator_statement +target_operator +domain_constraint +create_transform_statement +create_access_method +create_user_or_role +user_or_role_option +user_or_role_option_for_alter +user_or_role_or_group_common_option +user_or_role_common_option +user_or_role_or_group_option_for_create +create_group +group_option +create_tablespace +create_statistics +create_foreign_data_wrapper +option_without_equal +create_operator_statement +operator_name +operator_option +create_aggregate_statement +aggregate_param +set_statement +set_action +session_local_option +set_statement_value +create_rewrite_statement +rewrite_command +create_trigger_statement +trigger_referencing +when_trigger +rule_common +rule_member_object +columns_permissions +table_column_privileges +permissions +permission +other_rules +grant_to_rule +revoke_from_cascade_restrict +roles_names +role_name_with_group +comment_on_statement +security_label +comment_member_object +label_member_object +create_function_statement +create_funct_params +transform_for_type +function_ret_table +function_column_name_type +function_parameters +function_args +agg_order +character_string +function_arguments +argmode +create_sequence_statement +sequence_body +signed_number_literal +signed_numerical_literal +sign +create_schema_statement +create_policy_statement +alter_policy_statement +drop_policy_statement +create_subscription_statement +alter_subscription_statement +alter_subscription_action +create_cast_statement +drop_cast_statement +create_operator_family_statement +alter_operator_family_statement +operator_family_action +add_operator_to_family +drop_operator_from_family +drop_operator_family_statement +create_operator_class_statement +create_operator_class_option +alter_operator_class_statement +drop_operator_class_statement +create_conversion_statement +alter_conversion_statement +create_publication_statement +alter_publication_statement +alter_publication_action +only_table_multiply +alter_trigger_statement +alter_rule_statement +copy_statement +copy_from_statement +copy_to_statement +copy_option_list +copy_option +create_view_statement +if_exists +if_not_exists +view_columns +with_check_option +create_table_statement +create_table_as_statement +create_foreign_table_statement +define_table +define_partition +for_values_bound +partition_bound_spec +partition_bound_part +define_columns +define_type +partition_by +partition_method +partition_column +define_server +define_foreign_options +foreign_option +foreign_option_name +list_of_type_column_def +table_column_def +table_of_type_column_def +table_column_definition +like_option +constraint_common +constr_body +all_op +all_simple_op +op_chars +index_parameters +names_in_parens +names_references +storage_parameter +storage_parameter_option +storage_parameter_name +with_storage_parameter +storage_parameter_oid +on_commit +table_space +action +owner_to +rename_to +set_schema +table_column_privilege +usage_select_update +partition_by_columns +cascade_restrict +collate_identifier +indirection_var +dollar_number +indirection_list +indirection +drop_function_statement +drop_trigger_statement +drop_rule_statement +drop_statements +if_exist_names_restrict_cascade +id_token +identifier +identifier_nontype +col_label +tokens_nonreserved +tokens_nonreserved_except_function_type +tokens_reserved_except_function_type +tokens_reserved +tokens_nonkeyword +schema_qualified_name_nontype +type_list +data_type +array_type +predefined_type +interval_field +type_length +precision_param +vex +vex_b +op +all_op_ref +datetime_overlaps +value_expression_primary +unsigned_value_specification +unsigned_numeric_literal +truth_value +case_expression +cast_specification +function_call +vex_or_named_notation +pointer +function_construct +extract_function +system_function +date_time_function +string_value_function +xml_function +xml_table_column +comparison_mod +filter_clause +window_definition +frame_clause +frame_bound +array_expression +array_elements +type_coercion +schema_qualified_name +set_qualifier +table_subquery +select_stmt +after_ops +select_stmt_no_parens +with_clause +with_query +select_ops +select_ops_no_parens +select_primary +select_list +select_sublist +into_table +from_item +from_primary +alias_clause +from_function_column_def +groupby_clause +grouping_element_list +grouping_element +values_stmt +values_values +orderby_clause +sort_specifier_list +sort_specifier +order_specification +null_ordering +insert_stmt_for_psql +insert_columns +indirection_identifier +conflict_object +conflict_action +delete_stmt_for_psql +update_stmt_for_psql +update_set +notify_stmt +truncate_stmt +identifier_list +anonymous_block +comp_options +function_block +start_label +declarations +declaration +type_declaration +arguments_list +data_type_dec +exception_statement +function_statements +function_statement +base_statement +var +diagnostic_option +perform_stmt +assign_stmt +execute_stmt +control_statement +cursor_statement +option +transaction_statement +message_statement +log_level +raise_using +raise_param +return_stmt +loop_statement +loop_start +using_vex +if_statement +case_statement +plpgsql_query + + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 624, 7641, 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, 3, 2, 5, 2, 764, 10, 2, 3, 2, 7, 2, 767, 10, 2, 12, 2, 14, 2, 770, 11, 2, 3, 2, 3, 2, 6, 2, 774, 10, 2, 13, 2, 14, 2, 775, 3, 2, 5, 2, 779, 10, 2, 7, 2, 781, 10, 2, 12, 2, 14, 2, 784, 11, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 4, 5, 4, 792, 10, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 7, 5, 800, 10, 5, 12, 5, 14, 5, 803, 11, 5, 3, 5, 3, 5, 3, 6, 5, 6, 808, 10, 6, 3, 6, 3, 6, 5, 6, 812, 10, 6, 3, 6, 3, 6, 3, 7, 5, 7, 817, 10, 7, 3, 7, 3, 7, 3, 7, 7, 7, 822, 10, 7, 12, 7, 14, 7, 825, 11, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 5, 8, 832, 10, 8, 3, 9, 3, 9, 3, 9, 3, 9, 5, 9, 838, 10, 9, 3, 10, 3, 10, 5, 10, 842, 10, 10, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 848, 10, 11, 5, 11, 850, 10, 11, 3, 11, 3, 11, 3, 11, 7, 11, 855, 10, 11, 12, 11, 14, 11, 858, 11, 11, 5, 11, 860, 10, 11, 3, 11, 3, 11, 5, 11, 864, 10, 11, 3, 11, 3, 11, 5, 11, 868, 10, 11, 3, 11, 5, 11, 871, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 877, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 883, 10, 11, 5, 11, 885, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 893, 10, 11, 3, 11, 3, 11, 5, 11, 897, 10, 11, 3, 11, 3, 11, 5, 11, 901, 10, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 912, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 919, 10, 12, 3, 12, 5, 12, 922, 10, 12, 3, 13, 3, 13, 5, 13, 926, 10, 13, 3, 13, 3, 13, 3, 13, 7, 13, 931, 10, 13, 12, 13, 14, 13, 934, 11, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 940, 10, 13, 3, 13, 5, 13, 943, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 954, 10, 14, 3, 14, 5, 14, 957, 10, 14, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 963, 10, 15, 3, 15, 3, 15, 5, 15, 967, 10, 15, 3, 15, 5, 15, 970, 10, 15, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 976, 10, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 986, 10, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 994, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 7, 16, 1001, 10, 16, 12, 16, 14, 16, 1004, 11, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1009, 10, 16, 3, 16, 5, 16, 1012, 10, 16, 3, 16, 3, 16, 5, 16, 1016, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1025, 10, 16, 5, 16, 1027, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1034, 10, 16, 3, 16, 3, 16, 5, 16, 1038, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1044, 10, 16, 3, 16, 3, 16, 5, 16, 1048, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1055, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1063, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1069, 10, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1074, 10, 16, 3, 16, 5, 16, 1077, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 7, 16, 1085, 10, 16, 12, 16, 14, 16, 1088, 11, 16, 3, 16, 3, 16, 5, 16, 1092, 10, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 7, 16, 1103, 10, 16, 12, 16, 14, 16, 1106, 11, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1114, 10, 16, 3, 17, 3, 17, 5, 17, 1118, 10, 17, 3, 17, 5, 17, 1121, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 7, 17, 1127, 10, 17, 12, 17, 14, 17, 1130, 11, 17, 3, 17, 3, 17, 5, 17, 1134, 10, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 1144, 10, 18, 5, 18, 1146, 10, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 7, 19, 1154, 10, 19, 12, 19, 14, 19, 1157, 11, 19, 3, 19, 3, 19, 5, 19, 1161, 10, 19, 3, 20, 3, 20, 3, 20, 5, 20, 1166, 10, 20, 3, 20, 5, 20, 1169, 10, 20, 3, 20, 5, 20, 1172, 10, 20, 3, 20, 5, 20, 1175, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 1180, 10, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 1189, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 1200, 10, 21, 3, 22, 3, 22, 5, 22, 1204, 10, 22, 3, 22, 3, 22, 5, 22, 1208, 10, 22, 3, 23, 3, 23, 3, 23, 5, 23, 1213, 10, 23, 3, 24, 3, 24, 3, 24, 7, 24, 1218, 10, 24, 12, 24, 14, 24, 1221, 11, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 7, 25, 1228, 10, 25, 12, 25, 14, 25, 1231, 11, 25, 3, 25, 3, 25, 5, 25, 1235, 10, 25, 3, 26, 3, 26, 3, 26, 3, 26, 7, 26, 1241, 10, 26, 12, 26, 14, 26, 1244, 11, 26, 3, 26, 3, 26, 3, 26, 5, 26, 1249, 10, 26, 3, 26, 5, 26, 1252, 10, 26, 3, 26, 5, 26, 1255, 10, 26, 3, 26, 5, 26, 1258, 10, 26, 5, 26, 1260, 10, 26, 3, 27, 3, 27, 5, 27, 1264, 10, 27, 3, 28, 3, 28, 5, 28, 1268, 10, 28, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 5, 30, 1277, 10, 30, 3, 30, 3, 30, 3, 30, 3, 30, 5, 30, 1283, 10, 30, 3, 30, 3, 30, 5, 30, 1287, 10, 30, 5, 30, 1289, 10, 30, 3, 31, 3, 31, 3, 31, 5, 31, 1294, 10, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 5, 32, 1335, 10, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 5, 32, 1342, 10, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33, 1377, 10, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 1391, 10, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 1400, 10, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 1406, 10, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 1414, 10, 35, 3, 36, 3, 36, 5, 36, 1418, 10, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 1425, 10, 36, 3, 36, 3, 36, 5, 36, 1429, 10, 36, 6, 36, 1431, 10, 36, 13, 36, 14, 36, 1432, 3, 36, 5, 36, 1436, 10, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 1444, 10, 36, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37, 1450, 10, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39, 1461, 10, 39, 5, 39, 1463, 10, 39, 3, 39, 3, 39, 5, 39, 1467, 10, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 1500, 10, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 1519, 10, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 1559, 10, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 5, 42, 1566, 10, 42, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 1572, 10, 42, 3, 43, 5, 43, 1575, 10, 43, 3, 43, 3, 43, 5, 43, 1579, 10, 43, 3, 43, 5, 43, 1582, 10, 43, 3, 43, 3, 43, 5, 43, 1586, 10, 43, 3, 43, 3, 43, 3, 43, 7, 43, 1591, 10, 43, 12, 43, 14, 43, 1594, 11, 43, 3, 43, 3, 43, 5, 43, 1598, 10, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 1620, 10, 43, 3, 44, 3, 44, 5, 44, 1624, 10, 44, 3, 44, 5, 44, 1627, 10, 44, 3, 44, 3, 44, 3, 44, 5, 44, 1632, 10, 44, 3, 44, 5, 44, 1635, 10, 44, 3, 44, 3, 44, 5, 44, 1639, 10, 44, 3, 44, 3, 44, 5, 44, 1643, 10, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 1652, 10, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 1661, 10, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 1679, 10, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 1721, 10, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 1727, 10, 44, 3, 44, 5, 44, 1730, 10, 44, 5, 44, 1732, 10, 44, 3, 45, 3, 45, 5, 45, 1736, 10, 45, 3, 45, 3, 45, 3, 45, 5, 45, 1741, 10, 45, 3, 45, 3, 45, 5, 45, 1745, 10, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 1753, 10, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 1760, 10, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 6, 45, 1774, 10, 45, 13, 45, 14, 45, 1775, 5, 45, 1778, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 5, 46, 1784, 10, 46, 3, 46, 3, 46, 3, 46, 3, 46, 6, 46, 1790, 10, 46, 13, 46, 14, 46, 1791, 3, 46, 3, 46, 5, 46, 1796, 10, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 1803, 10, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 1809, 10, 47, 3, 47, 5, 47, 1812, 10, 47, 5, 47, 1814, 10, 47, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 5, 50, 1825, 10, 50, 3, 50, 3, 50, 5, 50, 1829, 10, 50, 3, 51, 5, 51, 1832, 10, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 5, 53, 1842, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 7, 53, 1851, 10, 53, 12, 53, 14, 53, 1854, 11, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 1861, 10, 53, 3, 53, 3, 53, 5, 53, 1865, 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, 5, 53, 1881, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 1888, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 1895, 10, 53, 3, 54, 3, 54, 3, 54, 5, 54, 1900, 10, 54, 3, 55, 3, 55, 5, 55, 1904, 10, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 1917, 10, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 1923, 10, 55, 5, 55, 1925, 10, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 1937, 10, 56, 3, 56, 5, 56, 1940, 10, 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, 7, 56, 1959, 10, 56, 12, 56, 14, 56, 1962, 11, 56, 3, 56, 3, 56, 5, 56, 1966, 10, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 5, 57, 1973, 10, 57, 3, 57, 3, 57, 3, 57, 5, 57, 1978, 10, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 5, 58, 1985, 10, 58, 5, 58, 1987, 10, 58, 3, 58, 3, 58, 3, 58, 7, 58, 1992, 10, 58, 12, 58, 14, 58, 1995, 11, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 7, 58, 2003, 10, 58, 12, 58, 14, 58, 2006, 11, 58, 3, 58, 3, 58, 5, 58, 2010, 10, 58, 5, 58, 2012, 10, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 2019, 10, 58, 5, 58, 2021, 10, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 2029, 10, 58, 5, 58, 2031, 10, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 2038, 10, 58, 5, 58, 2040, 10, 58, 3, 58, 3, 58, 5, 58, 2044, 10, 58, 3, 58, 3, 58, 5, 58, 2048, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 5, 60, 2056, 10, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 2062, 10, 60, 3, 60, 5, 60, 2065, 10, 60, 7, 60, 2067, 10, 60, 12, 60, 14, 60, 2070, 11, 60, 3, 60, 3, 60, 5, 60, 2074, 10, 60, 3, 61, 5, 61, 2077, 10, 61, 3, 61, 3, 61, 5, 61, 2081, 10, 61, 3, 61, 3, 61, 3, 61, 5, 61, 2086, 10, 61, 3, 61, 3, 61, 3, 61, 5, 61, 2091, 10, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 5, 61, 2099, 10, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 5, 63, 2109, 10, 63, 3, 63, 3, 63, 5, 63, 2113, 10, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 2122, 10, 64, 3, 64, 3, 64, 3, 64, 5, 64, 2127, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 2135, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 7, 64, 2146, 10, 64, 12, 64, 14, 64, 2149, 11, 64, 5, 64, 2151, 10, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 2164, 10, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 2176, 10, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 5, 67, 2184, 10, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 5, 67, 2191, 10, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 5, 68, 2199, 10, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 5, 68, 2209, 10, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 7, 69, 2219, 10, 69, 12, 69, 14, 69, 2222, 11, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 2228, 10, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 2239, 10, 69, 3, 69, 3, 69, 5, 69, 2243, 10, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2250, 10, 70, 3, 70, 5, 70, 2253, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2258, 10, 70, 3, 70, 3, 70, 5, 70, 2262, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2269, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2274, 10, 70, 3, 70, 5, 70, 2277, 10, 70, 5, 70, 2279, 10, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 73, 5, 73, 2289, 10, 73, 3, 73, 3, 73, 5, 73, 2293, 10, 73, 3, 73, 5, 73, 2296, 10, 73, 3, 73, 5, 73, 2299, 10, 73, 3, 73, 3, 73, 5, 73, 2303, 10, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 5, 74, 2310, 10, 74, 3, 74, 3, 74, 5, 74, 2314, 10, 74, 3, 74, 5, 74, 2317, 10, 74, 3, 74, 5, 74, 2320, 10, 74, 3, 74, 5, 74, 2323, 10, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 7, 76, 2334, 10, 76, 12, 76, 14, 76, 2337, 11, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 5, 78, 2346, 10, 78, 3, 78, 3, 78, 5, 78, 2350, 10, 78, 3, 78, 3, 78, 5, 78, 2354, 10, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2359, 10, 78, 5, 78, 2361, 10, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2366, 10, 78, 5, 78, 2368, 10, 78, 3, 78, 5, 78, 2371, 10, 78, 3, 79, 3, 79, 5, 79, 2375, 10, 79, 3, 79, 5, 79, 2378, 10, 79, 3, 79, 5, 79, 2381, 10, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 2389, 10, 79, 3, 79, 3, 79, 5, 79, 2393, 10, 79, 5, 79, 2395, 10, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 7, 80, 2409, 10, 80, 12, 80, 14, 80, 2412, 11, 80, 3, 80, 3, 80, 5, 80, 2416, 10, 80, 6, 80, 2418, 10, 80, 13, 80, 14, 80, 2419, 5, 80, 2422, 10, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 7, 81, 2435, 10, 81, 12, 81, 14, 81, 2438, 11, 81, 5, 81, 2440, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 7, 81, 2448, 10, 81, 12, 81, 14, 81, 2451, 11, 81, 5, 81, 2453, 10, 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, 81, 3, 81, 3, 81, 3, 81, 5, 81, 2473, 10, 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, 81, 3, 81, 5, 81, 2491, 10, 81, 7, 81, 2493, 10, 81, 12, 81, 14, 81, 2496, 11, 81, 3, 81, 5, 81, 2499, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 2506, 10, 81, 3, 81, 5, 81, 2509, 10, 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, 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, 5, 81, 2538, 10, 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, 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, 5, 81, 2568, 10, 81, 7, 81, 2570, 10, 81, 12, 81, 14, 81, 2573, 11, 81, 3, 81, 3, 81, 5, 81, 2577, 10, 81, 3, 82, 3, 82, 3, 82, 5, 82, 2582, 10, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 7, 82, 2589, 10, 82, 12, 82, 14, 82, 2592, 11, 82, 3, 83, 3, 83, 5, 83, 2596, 10, 83, 3, 83, 3, 83, 3, 83, 5, 83, 2601, 10, 83, 3, 83, 3, 83, 5, 83, 2605, 10, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 5, 83, 2612, 10, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 7, 84, 2624, 10, 84, 12, 84, 14, 84, 2627, 11, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 2646, 10, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2660, 10, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2669, 10, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 2695, 10, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 2704, 10, 88, 3, 88, 3, 88, 3, 89, 3, 89, 5, 89, 2710, 10, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 7, 89, 2719, 10, 89, 12, 89, 14, 89, 2722, 11, 89, 5, 89, 2724, 10, 89, 3, 89, 5, 89, 2727, 10, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 5, 90, 2736, 10, 90, 3, 91, 3, 91, 3, 91, 3, 91, 5, 91, 2742, 10, 91, 3, 91, 3, 91, 3, 91, 5, 91, 2747, 10, 91, 3, 92, 3, 92, 3, 92, 5, 92, 2752, 10, 92, 3, 92, 3, 92, 3, 92, 5, 92, 2757, 10, 92, 3, 92, 3, 92, 3, 92, 5, 92, 2762, 10, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 5, 93, 2769, 10, 93, 3, 93, 3, 93, 3, 93, 5, 93, 2774, 10, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 5, 94, 2783, 10, 94, 3, 94, 6, 94, 2786, 10, 94, 13, 94, 14, 94, 2787, 5, 94, 2790, 10, 94, 3, 95, 3, 95, 5, 95, 2794, 10, 95, 3, 95, 3, 95, 3, 95, 5, 95, 2799, 10, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 5, 96, 2807, 10, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 5, 96, 2817, 10, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 5, 96, 2827, 10, 96, 3, 96, 3, 96, 3, 96, 5, 96, 2832, 10, 96, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 5, 98, 2845, 10, 98, 3, 99, 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, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 2871, 10, 100, 3, 100, 5, 100, 2874, 10, 100, 3, 100, 5, 100, 2877, 10, 100, 3, 100, 5, 100, 2880, 10, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 7, 101, 2891, 10, 101, 12, 101, 14, 101, 2894, 11, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 2903, 10, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 5, 102, 2910, 10, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 5, 104, 2922, 10, 104, 3, 104, 3, 104, 3, 104, 3, 104, 5, 104, 2928, 10, 104, 3, 104, 5, 104, 2931, 10, 104, 3, 104, 3, 104, 5, 104, 2935, 10, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 7, 106, 2947, 10, 106, 12, 106, 14, 106, 2950, 11, 106, 3, 106, 3, 106, 5, 106, 2954, 10, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 5, 108, 2963, 10, 108, 3, 108, 3, 108, 3, 108, 5, 108, 2968, 10, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 7, 109, 2978, 10, 109, 12, 109, 14, 109, 2981, 11, 109, 3, 109, 5, 109, 2984, 10, 109, 3, 110, 3, 110, 5, 110, 2988, 10, 110, 3, 110, 3, 110, 3, 110, 7, 110, 2993, 10, 110, 12, 110, 14, 110, 2996, 11, 110, 3, 110, 5, 110, 2999, 10, 110, 3, 111, 3, 111, 3, 111, 3, 111, 5, 111, 3005, 10, 111, 3, 111, 3, 111, 3, 111, 5, 111, 3010, 10, 111, 3, 111, 3, 111, 3, 112, 3, 112, 5, 112, 3016, 10, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 5, 112, 3024, 10, 112, 3, 112, 5, 112, 3027, 10, 112, 3, 113, 3, 113, 5, 113, 3031, 10, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 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, 115, 3, 115, 3, 115, 5, 115, 3063, 10, 115, 3, 115, 3, 115, 7, 115, 3067, 10, 115, 12, 115, 14, 115, 3070, 11, 115, 5, 115, 3072, 10, 115, 3, 116, 3, 116, 3, 116, 5, 116, 3077, 10, 116, 3, 117, 3, 117, 5, 117, 3081, 10, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 5, 118, 3094, 10, 118, 3, 118, 3, 118, 3, 118, 5, 118, 3099, 10, 118, 3, 118, 3, 118, 3, 118, 5, 118, 3104, 10, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 5, 119, 3113, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 3124, 10, 120, 3, 120, 5, 120, 3127, 10, 120, 3, 121, 3, 121, 3, 121, 5, 121, 3132, 10, 121, 3, 121, 6, 121, 3135, 10, 121, 13, 121, 14, 121, 3136, 5, 121, 3139, 10, 121, 3, 122, 3, 122, 5, 122, 3143, 10, 122, 3, 123, 3, 123, 3, 123, 3, 123, 5, 123, 3149, 10, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 7, 123, 3158, 10, 123, 12, 123, 14, 123, 3161, 11, 123, 3, 123, 3, 123, 5, 123, 3165, 10, 123, 3, 124, 3, 124, 5, 124, 3169, 10, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 5, 124, 3176, 10, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 5, 125, 3193, 10, 125, 3, 125, 3, 125, 3, 125, 3, 125, 5, 125, 3199, 10, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 7, 125, 3206, 10, 125, 12, 125, 14, 125, 3209, 11, 125, 3, 125, 3, 125, 5, 125, 3213, 10, 125, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 7, 127, 3224, 10, 127, 12, 127, 14, 127, 3227, 11, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 5, 128, 3234, 10, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 5, 129, 3255, 10, 129, 3, 130, 3, 130, 5, 130, 3259, 10, 130, 3, 130, 3, 130, 3, 130, 5, 130, 3264, 10, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 5, 130, 3272, 10, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 7, 130, 3283, 10, 130, 12, 130, 14, 130, 3286, 11, 130, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 5, 131, 3341, 10, 131, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 5, 133, 3349, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 7, 133, 3356, 10, 133, 12, 133, 14, 133, 3359, 11, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 7, 133, 3371, 10, 133, 12, 133, 14, 133, 3374, 11, 133, 3, 133, 5, 133, 3377, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 3383, 10, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 3390, 10, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 3398, 10, 134, 3, 134, 3, 134, 3, 134, 5, 134, 3403, 10, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 3412, 10, 134, 5, 134, 3414, 10, 134, 3, 135, 3, 135, 3, 135, 7, 135, 3419, 10, 135, 12, 135, 14, 135, 3422, 11, 135, 3, 135, 5, 135, 3425, 10, 135, 3, 136, 3, 136, 5, 136, 3429, 10, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 5, 136, 3440, 10, 136, 3, 136, 3, 136, 5, 136, 3444, 10, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 7, 136, 3452, 10, 136, 12, 136, 14, 136, 3455, 11, 136, 3, 136, 3, 136, 5, 136, 3459, 10, 136, 3, 136, 3, 136, 5, 136, 3463, 10, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 5, 137, 3470, 10, 137, 3, 138, 5, 138, 3473, 10, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3481, 10, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3486, 10, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3491, 10, 138, 5, 138, 3493, 10, 138, 3, 138, 5, 138, 3496, 10, 138, 6, 138, 3498, 10, 138, 13, 138, 14, 138, 3499, 3, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3506, 10, 138, 3, 138, 5, 138, 3509, 10, 138, 3, 138, 5, 138, 3512, 10, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3517, 10, 138, 5, 138, 3519, 10, 138, 3, 138, 3, 138, 5, 138, 3523, 10, 138, 3, 138, 5, 138, 3526, 10, 138, 3, 138, 5, 138, 3529, 10, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 139, 3, 139, 3, 139, 5, 139, 3538, 10, 139, 3, 139, 3, 139, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 141, 3, 141, 3, 141, 5, 141, 3550, 10, 141, 5, 141, 3552, 10, 141, 3, 141, 3, 141, 5, 141, 3556, 10, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 3566, 10, 141, 3, 141, 5, 141, 3569, 10, 141, 3, 142, 5, 142, 3572, 10, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 7, 142, 3592, 10, 142, 12, 142, 14, 142, 3595, 11, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 7, 142, 3602, 10, 142, 12, 142, 14, 142, 3605, 11, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 3620, 10, 142, 3, 143, 3, 143, 3, 143, 7, 143, 3625, 10, 143, 12, 143, 14, 143, 3628, 11, 143, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 7, 145, 3638, 10, 145, 12, 145, 14, 145, 3641, 11, 145, 3, 146, 3, 146, 5, 146, 3645, 10, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 5, 146, 3659, 10, 146, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3668, 10, 147, 3, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3674, 10, 147, 3, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3680, 10, 147, 5, 147, 3682, 10, 147, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 5, 148, 3689, 10, 148, 3, 149, 3, 149, 3, 149, 5, 149, 3694, 10, 149, 3, 150, 3, 150, 3, 150, 7, 150, 3699, 10, 150, 12, 150, 14, 150, 3702, 11, 150, 3, 151, 5, 151, 3705, 10, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 5, 152, 3715, 10, 152, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 3722, 10, 153, 5, 153, 3724, 10, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 3731, 10, 153, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 3755, 10, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 3775, 10, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 3785, 10, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 3803, 10, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 3857, 10, 154, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 3873, 10, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 3881, 10, 155, 3, 155, 3, 155, 3, 155, 5, 155, 3886, 10, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 3904, 10, 155, 3, 156, 3, 156, 5, 156, 3908, 10, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 3915, 10, 156, 5, 156, 3917, 10, 156, 3, 156, 3, 156, 3, 157, 6, 157, 3922, 10, 157, 13, 157, 14, 157, 3923, 3, 157, 5, 157, 3927, 10, 157, 3, 158, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 7, 159, 3938, 10, 159, 12, 159, 14, 159, 3941, 11, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 3, 162, 3, 162, 7, 162, 3955, 10, 162, 12, 162, 14, 162, 3958, 11, 162, 5, 162, 3960, 10, 162, 3, 162, 5, 162, 3963, 10, 162, 3, 162, 5, 162, 3966, 10, 162, 3, 162, 3, 162, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 7, 163, 3975, 10, 163, 12, 163, 14, 163, 3978, 11, 163, 3, 164, 3, 164, 7, 164, 3982, 10, 164, 12, 164, 14, 164, 3985, 11, 164, 3, 164, 3, 164, 5, 164, 3989, 10, 164, 3, 165, 5, 165, 3992, 10, 165, 3, 165, 5, 165, 3995, 10, 165, 3, 165, 3, 165, 3, 165, 5, 165, 4000, 10, 165, 3, 166, 3, 166, 3, 167, 5, 167, 4005, 10, 167, 3, 167, 3, 167, 5, 167, 4009, 10, 167, 3, 167, 3, 167, 7, 167, 4013, 10, 167, 12, 167, 14, 167, 4016, 11, 167, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 4025, 10, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 4032, 10, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 4038, 10, 168, 3, 168, 3, 168, 5, 168, 4042, 10, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 4048, 10, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 4054, 10, 168, 3, 169, 5, 169, 4057, 10, 169, 3, 169, 3, 169, 3, 170, 5, 170, 4062, 10, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 172, 3, 172, 5, 172, 4070, 10, 172, 3, 172, 5, 172, 4073, 10, 172, 3, 172, 3, 172, 5, 172, 4077, 10, 172, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 5, 173, 4085, 10, 173, 3, 173, 3, 173, 5, 173, 4089, 10, 173, 3, 173, 3, 173, 3, 173, 3, 173, 7, 173, 4095, 10, 173, 12, 173, 14, 173, 4098, 11, 173, 5, 173, 4100, 10, 173, 3, 173, 3, 173, 5, 173, 4104, 10, 173, 3, 173, 3, 173, 3, 173, 5, 173, 4109, 10, 173, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 7, 174, 4125, 10, 174, 12, 174, 14, 174, 4128, 11, 174, 5, 174, 4130, 10, 174, 3, 174, 3, 174, 5, 174, 4134, 10, 174, 3, 174, 3, 174, 3, 174, 5, 174, 4139, 10, 174, 5, 174, 4141, 10, 174, 3, 175, 3, 175, 5, 175, 4145, 10, 175, 3, 175, 3, 175, 3, 175, 3, 175, 5, 175, 4151, 10, 175, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 5, 176, 4160, 10, 176, 3, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 5, 178, 4172, 10, 178, 3, 178, 3, 178, 3, 178, 5, 178, 4177, 10, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 5, 178, 4185, 10, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 4202, 10, 179, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 4208, 10, 179, 3, 180, 3, 180, 5, 180, 4212, 10, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 5, 180, 4220, 10, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 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, 7, 183, 4242, 10, 183, 12, 183, 14, 183, 4245, 11, 183, 3, 183, 3, 183, 3, 183, 3, 183, 7, 183, 4251, 10, 183, 12, 183, 14, 183, 4254, 11, 183, 5, 183, 4256, 10, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 4267, 10, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 4274, 10, 184, 3, 184, 3, 184, 3, 184, 5, 184, 4279, 10, 184, 5, 184, 4281, 10, 184, 3, 184, 5, 184, 4284, 10, 184, 3, 184, 3, 184, 5, 184, 4288, 10, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 5, 185, 4295, 10, 185, 3, 185, 3, 185, 3, 185, 5, 185, 4300, 10, 185, 5, 185, 4302, 10, 185, 3, 185, 3, 185, 3, 186, 3, 186, 3, 186, 5, 186, 4309, 10, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 4315, 10, 186, 3, 187, 3, 187, 3, 187, 3, 187, 5, 187, 4321, 10, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 5, 187, 4330, 10, 187, 3, 187, 3, 187, 3, 187, 3, 187, 7, 187, 4336, 10, 187, 12, 187, 14, 187, 4339, 11, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 4347, 10, 188, 3, 188, 3, 188, 3, 188, 5, 188, 4352, 10, 188, 3, 188, 5, 188, 4355, 10, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 4363, 10, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 4370, 10, 188, 3, 188, 3, 188, 3, 188, 5, 188, 4375, 10, 188, 5, 188, 4377, 10, 188, 3, 188, 5, 188, 4380, 10, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 4386, 10, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 5, 189, 4396, 10, 189, 3, 190, 3, 190, 3, 190, 5, 190, 4401, 10, 190, 3, 190, 3, 190, 3, 190, 3, 190, 5, 190, 4407, 10, 190, 3, 191, 5, 191, 4410, 10, 191, 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, 5, 192, 4426, 10, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 7, 193, 4435, 10, 193, 12, 193, 14, 193, 4438, 11, 193, 3, 193, 3, 193, 3, 193, 5, 193, 4443, 10, 193, 3, 193, 5, 193, 4446, 10, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 7, 195, 4461, 10, 195, 12, 195, 14, 195, 4464, 11, 195, 5, 195, 4466, 10, 195, 3, 196, 5, 196, 4469, 10, 196, 3, 196, 3, 196, 5, 196, 4473, 10, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 5, 197, 4484, 10, 197, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 5, 199, 4494, 10, 199, 3, 200, 3, 200, 3, 200, 3, 200, 5, 200, 4500, 10, 200, 3, 200, 3, 200, 5, 200, 4504, 10, 200, 3, 200, 5, 200, 4507, 10, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 5, 200, 4514, 10, 200, 5, 200, 4516, 10, 200, 3, 200, 3, 200, 5, 200, 4520, 10, 200, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 4528, 10, 201, 3, 201, 3, 201, 5, 201, 4532, 10, 201, 3, 201, 3, 201, 5, 201, 4536, 10, 201, 3, 201, 5, 201, 4539, 10, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 4546, 10, 201, 5, 201, 4548, 10, 201, 3, 202, 3, 202, 5, 202, 4552, 10, 202, 3, 202, 7, 202, 4555, 10, 202, 12, 202, 14, 202, 4558, 11, 202, 3, 203, 5, 203, 4561, 10, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4566, 10, 203, 3, 203, 3, 203, 5, 203, 4570, 10, 203, 3, 203, 3, 203, 5, 203, 4574, 10, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4579, 10, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4584, 10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4594, 10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4602, 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, 4620, 10, 203, 3, 204, 3, 204, 5, 204, 4624, 10, 204, 3, 204, 5, 204, 4627, 10, 204, 3, 204, 5, 204, 4630, 10, 204, 3, 204, 5, 204, 4633, 10, 204, 3, 204, 3, 204, 5, 204, 4637, 10, 204, 3, 204, 3, 204, 5, 204, 4641, 10, 204, 3, 204, 3, 204, 5, 204, 4645, 10, 204, 3, 204, 3, 204, 5, 204, 4649, 10, 204, 3, 204, 5, 204, 4652, 10, 204, 3, 204, 3, 204, 3, 204, 5, 204, 4657, 10, 204, 3, 204, 3, 204, 5, 204, 4661, 10, 204, 3, 204, 5, 204, 4664, 10, 204, 3, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 207, 3, 207, 3, 207, 3, 207, 7, 207, 4677, 10, 207, 12, 207, 14, 207, 4680, 11, 207, 3, 207, 3, 207, 3, 208, 3, 208, 5, 208, 4686, 10, 208, 3, 208, 3, 208, 3, 208, 3, 209, 5, 209, 4692, 10, 209, 3, 209, 3, 209, 5, 209, 4696, 10, 209, 3, 209, 3, 209, 5, 209, 4700, 10, 209, 3, 209, 3, 209, 3, 209, 5, 209, 4705, 10, 209, 3, 209, 3, 209, 5, 209, 4709, 10, 209, 3, 209, 5, 209, 4712, 10, 209, 3, 209, 5, 209, 4715, 10, 209, 3, 209, 5, 209, 4718, 10, 209, 3, 210, 5, 210, 4721, 10, 210, 3, 210, 3, 210, 5, 210, 4725, 10, 210, 3, 210, 3, 210, 5, 210, 4729, 10, 210, 3, 210, 3, 210, 5, 210, 4733, 10, 210, 3, 210, 3, 210, 5, 210, 4737, 10, 210, 3, 210, 5, 210, 4740, 10, 210, 3, 210, 5, 210, 4743, 10, 210, 3, 210, 5, 210, 4746, 10, 210, 3, 210, 3, 210, 3, 210, 3, 210, 5, 210, 4752, 10, 210, 3, 210, 3, 210, 5, 210, 4756, 10, 210, 3, 210, 5, 210, 4759, 10, 210, 3, 211, 3, 211, 3, 211, 5, 211, 4764, 10, 211, 3, 211, 3, 211, 3, 211, 5, 211, 4769, 10, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 5, 212, 4776, 10, 212, 3, 213, 3, 213, 3, 213, 3, 213, 5, 213, 4782, 10, 213, 3, 213, 3, 213, 3, 214, 3, 214, 3, 214, 3, 214, 5, 214, 4790, 10, 214, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 7, 215, 4797, 10, 215, 12, 215, 14, 215, 4800, 11, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 5, 215, 4817, 10, 215, 3, 216, 3, 216, 3, 216, 3, 216, 7, 216, 4823, 10, 216, 12, 216, 14, 216, 4826, 11, 216, 3, 216, 3, 216, 3, 217, 3, 217, 3, 217, 3, 217, 7, 217, 4834, 10, 217, 12, 217, 14, 217, 4837, 11, 217, 5, 217, 4839, 10, 217, 3, 217, 3, 217, 3, 217, 5, 217, 4844, 10, 217, 3, 218, 3, 218, 3, 218, 5, 218, 4849, 10, 218, 3, 219, 3, 219, 3, 219, 3, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 7, 220, 4860, 10, 220, 12, 220, 14, 220, 4863, 11, 220, 3, 220, 3, 220, 3, 221, 3, 221, 5, 221, 4869, 10, 221, 3, 222, 3, 222, 3, 222, 5, 222, 4874, 10, 222, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 7, 223, 4881, 10, 223, 12, 223, 14, 223, 4884, 11, 223, 3, 223, 3, 223, 3, 224, 5, 224, 4889, 10, 224, 3, 224, 3, 224, 5, 224, 4893, 10, 224, 3, 225, 3, 225, 5, 225, 4897, 10, 225, 3, 226, 3, 226, 3, 226, 3, 226, 7, 226, 4903, 10, 226, 12, 226, 14, 226, 4906, 11, 226, 3, 226, 3, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 7, 227, 4915, 10, 227, 12, 227, 14, 227, 4918, 11, 227, 5, 227, 4920, 10, 227, 3, 228, 3, 228, 3, 228, 5, 228, 4925, 10, 228, 3, 228, 7, 228, 4928, 10, 228, 12, 228, 14, 228, 4931, 11, 228, 3, 228, 5, 228, 4934, 10, 228, 3, 229, 3, 229, 3, 229, 5, 229, 4939, 10, 229, 3, 229, 5, 229, 4942, 10, 229, 3, 229, 7, 229, 4945, 10, 229, 12, 229, 14, 229, 4948, 11, 229, 3, 230, 3, 230, 3, 230, 3, 231, 3, 231, 5, 231, 4955, 10, 231, 3, 231, 3, 231, 5, 231, 4959, 10, 231, 3, 231, 5, 231, 4962, 10, 231, 3, 232, 3, 232, 3, 232, 5, 232, 4967, 10, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 7, 232, 4978, 10, 232, 12, 232, 14, 232, 4981, 11, 232, 3, 232, 3, 232, 3, 232, 3, 232, 5, 232, 4987, 10, 232, 3, 232, 3, 232, 3, 232, 5, 232, 4992, 10, 232, 3, 232, 3, 232, 3, 232, 5, 232, 4997, 10, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 7, 232, 5004, 10, 232, 12, 232, 14, 232, 5007, 11, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 5, 232, 5015, 10, 232, 3, 232, 5, 232, 5018, 10, 232, 3, 232, 3, 232, 3, 232, 3, 232, 5, 232, 5024, 10, 232, 3, 232, 5, 232, 5027, 10, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 5, 232, 5041, 10, 232, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 5, 233, 5056, 10, 233, 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, 5071, 10, 234, 3, 235, 3, 235, 3, 236, 5, 236, 5076, 10, 236, 3, 236, 5, 236, 5079, 10, 236, 3, 236, 3, 236, 3, 236, 3, 236, 5, 236, 5085, 10, 236, 5, 236, 5087, 10, 236, 3, 237, 3, 237, 3, 237, 3, 237, 3, 238, 3, 238, 3, 238, 7, 238, 5096, 10, 238, 12, 238, 14, 238, 5099, 11, 238, 3, 239, 3, 239, 3, 239, 3, 239, 7, 239, 5105, 10, 239, 12, 239, 14, 239, 5108, 11, 239, 3, 239, 3, 239, 3, 240, 3, 240, 3, 240, 5, 240, 5115, 10, 240, 3, 241, 3, 241, 3, 241, 5, 241, 5120, 10, 241, 3, 242, 3, 242, 3, 242, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 5, 243, 5130, 10, 243, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 5139, 10, 244, 3, 245, 3, 245, 3, 245, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 5, 246, 5149, 10, 246, 3, 247, 3, 247, 3, 247, 3, 247, 3, 247, 5, 247, 5156, 10, 247, 3, 248, 3, 248, 3, 248, 3, 248, 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, 5, 250, 5175, 10, 250, 5, 250, 5177, 10, 250, 3, 251, 3, 251, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 7, 252, 5186, 10, 252, 12, 252, 14, 252, 5189, 11, 252, 3, 253, 3, 253, 3, 254, 3, 254, 3, 254, 3, 255, 3, 255, 5, 255, 5198, 10, 255, 3, 255, 5, 255, 5201, 10, 255, 3, 256, 3, 256, 3, 257, 6, 257, 5206, 10, 257, 13, 257, 14, 257, 5207, 3, 257, 7, 257, 5211, 10, 257, 12, 257, 14, 257, 5214, 11, 257, 3, 257, 3, 257, 5, 257, 5218, 10, 257, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 5, 258, 5228, 10, 258, 3, 258, 3, 258, 5, 258, 5232, 10, 258, 3, 258, 5, 258, 5235, 10, 258, 3, 259, 3, 259, 5, 259, 5239, 10, 259, 3, 259, 3, 259, 5, 259, 5243, 10, 259, 3, 259, 5, 259, 5246, 10, 259, 3, 260, 3, 260, 5, 260, 5250, 10, 260, 3, 260, 3, 260, 3, 260, 3, 260, 5, 260, 5256, 10, 260, 3, 261, 3, 261, 5, 261, 5260, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 5266, 10, 261, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 5, 262, 5279, 10, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 5, 262, 5287, 10, 262, 3, 262, 5, 262, 5290, 10, 262, 3, 262, 3, 262, 5, 262, 5294, 10, 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, 5310, 10, 262, 3, 262, 3, 262, 3, 263, 5, 263, 5315, 10, 263, 3, 263, 3, 263, 5, 263, 5319, 10, 263, 3, 264, 3, 264, 3, 264, 5, 264, 5324, 10, 264, 3, 265, 3, 265, 3, 265, 5, 265, 5329, 10, 265, 3, 266, 3, 266, 3, 266, 5, 266, 5334, 10, 266, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 5, 267, 5341, 10, 267, 3, 268, 3, 268, 3, 269, 3, 269, 3, 270, 3, 270, 3, 271, 3, 271, 3, 272, 3, 272, 3, 273, 3, 273, 3, 273, 3, 273, 3, 273, 5, 273, 5358, 10, 273, 3, 274, 3, 274, 3, 274, 7, 274, 5363, 10, 274, 12, 274, 14, 274, 5366, 11, 274, 3, 275, 5, 275, 5369, 10, 275, 3, 275, 3, 275, 3, 275, 5, 275, 5374, 10, 275, 3, 275, 6, 275, 5377, 10, 275, 13, 275, 14, 275, 5378, 5, 275, 5381, 10, 275, 3, 276, 3, 276, 5, 276, 5385, 10, 276, 3, 276, 3, 276, 3, 277, 3, 277, 3, 277, 5, 277, 5392, 10, 277, 3, 277, 5, 277, 5395, 10, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5400, 10, 277, 3, 277, 3, 277, 5, 277, 5404, 10, 277, 3, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5410, 10, 277, 3, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5416, 10, 277, 3, 277, 5, 277, 5419, 10, 277, 3, 277, 5, 277, 5422, 10, 277, 3, 277, 3, 277, 5, 277, 5426, 10, 277, 3, 277, 5, 277, 5429, 10, 277, 3, 277, 3, 277, 5, 277, 5433, 10, 277, 3, 277, 5, 277, 5436, 10, 277, 3, 277, 3, 277, 5, 277, 5440, 10, 277, 3, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5446, 10, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5451, 10, 277, 3, 277, 3, 277, 5, 277, 5455, 10, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5460, 10, 277, 3, 277, 3, 277, 5, 277, 5464, 10, 277, 3, 277, 3, 277, 3, 277, 3, 277, 3, 277, 7, 277, 5471, 10, 277, 12, 277, 14, 277, 5474, 11, 277, 3, 277, 3, 277, 5, 277, 5478, 10, 277, 5, 277, 5480, 10, 277, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5509, 10, 278, 3, 279, 3, 279, 3, 279, 3, 279, 3, 280, 3, 280, 3, 280, 3, 280, 5, 280, 5519, 10, 280, 3, 280, 3, 280, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5528, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 6, 281, 5534, 10, 281, 13, 281, 14, 281, 5535, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5548, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5570, 10, 281, 3, 281, 3, 281, 5, 281, 5574, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5582, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5588, 10, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5593, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5599, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5611, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5631, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 7, 281, 5639, 10, 281, 12, 281, 14, 281, 5642, 11, 281, 5, 281, 5644, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5651, 10, 281, 3, 281, 3, 281, 5, 281, 5655, 10, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5660, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5666, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5672, 10, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 7, 281, 5683, 10, 281, 12, 281, 14, 281, 5686, 11, 281, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5693, 10, 282, 3, 282, 3, 282, 3, 282, 3, 282, 6, 282, 5699, 10, 282, 13, 282, 14, 282, 5700, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5711, 10, 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, 5732, 10, 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, 5745, 10, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5751, 10, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5757, 10, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 7, 282, 5764, 10, 282, 12, 282, 14, 282, 5767, 11, 282, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 5, 283, 5777, 10, 283, 3, 284, 3, 284, 3, 284, 3, 284, 3, 284, 3, 284, 3, 284, 3, 284, 5, 284, 5787, 10, 284, 3, 285, 3, 285, 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, 5, 286, 5806, 10, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 5, 286, 5819, 10, 286, 3, 287, 3, 287, 3, 287, 5, 287, 5824, 10, 287, 3, 288, 3, 288, 3, 289, 3, 289, 3, 290, 3, 290, 5, 290, 5832, 10, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 6, 290, 5839, 10, 290, 13, 290, 14, 290, 5840, 3, 290, 3, 290, 5, 290, 5845, 10, 290, 3, 290, 3, 290, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 292, 3, 292, 3, 292, 5, 292, 5859, 10, 292, 3, 292, 3, 292, 3, 292, 7, 292, 5864, 10, 292, 12, 292, 14, 292, 5867, 11, 292, 3, 292, 5, 292, 5870, 10, 292, 5, 292, 5872, 10, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 5, 292, 5881, 10, 292, 3, 292, 5, 292, 5884, 10, 292, 3, 292, 3, 292, 3, 292, 5, 292, 5889, 10, 292, 5, 292, 5891, 10, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 5, 292, 5899, 10, 292, 3, 293, 5, 293, 5902, 10, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5907, 10, 293, 3, 293, 3, 293, 3, 294, 3, 294, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 7, 295, 5918, 10, 295, 12, 295, 14, 295, 5921, 11, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 7, 295, 5930, 10, 295, 12, 295, 14, 295, 5933, 11, 295, 5, 295, 5935, 10, 295, 3, 295, 5, 295, 5938, 10, 295, 3, 296, 3, 296, 3, 296, 3, 296, 5, 296, 5944, 10, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 5, 297, 5956, 10, 297, 3, 298, 3, 298, 3, 298, 5, 298, 5961, 10, 298, 3, 298, 3, 298, 5, 298, 5965, 10, 298, 3, 298, 3, 298, 5, 298, 5969, 10, 298, 3, 298, 3, 298, 5, 298, 5973, 10, 298, 5, 298, 5975, 10, 298, 3, 299, 3, 299, 3, 299, 5, 299, 5980, 10, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 5, 299, 5987, 10, 299, 3, 299, 3, 299, 3, 299, 5, 299, 5992, 10, 299, 5, 299, 5994, 10, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 7, 299, 6003, 10, 299, 12, 299, 14, 299, 6006, 11, 299, 3, 299, 3, 299, 5, 299, 6010, 10, 299, 3, 299, 3, 299, 5, 299, 6014, 10, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 5, 299, 6034, 10, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 5, 299, 6044, 10, 299, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6056, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6062, 10, 300, 7, 300, 6064, 10, 300, 12, 300, 14, 300, 6067, 11, 300, 3, 300, 3, 300, 5, 300, 6071, 10, 300, 3, 300, 3, 300, 7, 300, 6075, 10, 300, 12, 300, 14, 300, 6078, 11, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6087, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6093, 10, 300, 7, 300, 6095, 10, 300, 12, 300, 14, 300, 6098, 11, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6108, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6120, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6128, 10, 300, 5, 300, 6130, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6140, 10, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6145, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 3, 300, 7, 300, 6175, 10, 300, 12, 300, 14, 300, 6178, 11, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6183, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6189, 10, 300, 3, 300, 3, 300, 3, 300, 5, 300, 6194, 10, 300, 3, 300, 3, 300, 3, 300, 3, 300, 7, 300, 6200, 10, 300, 12, 300, 14, 300, 6203, 11, 300, 3, 300, 3, 300, 5, 300, 6207, 10, 300, 3, 301, 3, 301, 3, 301, 3, 301, 5, 301, 6213, 10, 301, 3, 301, 3, 301, 5, 301, 6217, 10, 301, 3, 301, 5, 301, 6220, 10, 301, 3, 301, 5, 301, 6223, 10, 301, 3, 301, 3, 301, 5, 301, 6227, 10, 301, 3, 302, 3, 302, 3, 302, 3, 302, 5, 302, 6233, 10, 302, 3, 302, 3, 302, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 304, 3, 304, 5, 304, 6245, 10, 304, 3, 304, 5, 304, 6248, 10, 304, 3, 304, 5, 304, 6251, 10, 304, 3, 304, 5, 304, 6254, 10, 304, 3, 304, 3, 304, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 5, 305, 6265, 10, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 5, 305, 6274, 10, 305, 5, 305, 6276, 10, 305, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 5, 306, 6283, 10, 306, 3, 307, 3, 307, 3, 307, 5, 307, 6288, 10, 307, 3, 308, 3, 308, 3, 308, 5, 308, 6293, 10, 308, 3, 308, 3, 308, 3, 308, 5, 308, 6298, 10, 308, 7, 308, 6300, 10, 308, 12, 308, 14, 308, 6303, 11, 308, 5, 308, 6305, 10, 308, 3, 308, 3, 308, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 5, 309, 6316, 10, 309, 5, 309, 6318, 10, 309, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 5, 310, 6325, 10, 310, 5, 310, 6327, 10, 310, 3, 311, 3, 311, 3, 312, 3, 312, 3, 312, 3, 312, 3, 313, 5, 313, 6336, 10, 313, 3, 313, 3, 313, 7, 313, 6340, 10, 313, 12, 313, 14, 313, 6343, 11, 313, 3, 314, 3, 314, 3, 314, 3, 314, 5, 314, 6349, 10, 314, 3, 314, 3, 314, 3, 314, 5, 314, 6354, 10, 314, 3, 314, 3, 314, 3, 314, 5, 314, 6359, 10, 314, 3, 314, 3, 314, 5, 314, 6363, 10, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 5, 314, 6373, 10, 314, 3, 314, 3, 314, 3, 314, 3, 314, 7, 314, 6379, 10, 314, 12, 314, 14, 314, 6382, 11, 314, 5, 314, 6384, 10, 314, 3, 314, 3, 314, 3, 314, 5, 314, 6389, 10, 314, 5, 314, 6391, 10, 314, 3, 315, 5, 315, 6394, 10, 315, 3, 315, 3, 315, 7, 315, 6398, 10, 315, 12, 315, 14, 315, 6401, 11, 315, 3, 316, 3, 316, 5, 316, 6405, 10, 316, 3, 316, 3, 316, 3, 316, 7, 316, 6410, 10, 316, 12, 316, 14, 316, 6413, 11, 316, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 7, 317, 6420, 10, 317, 12, 317, 14, 317, 6423, 11, 317, 3, 317, 3, 317, 5, 317, 6427, 10, 317, 3, 317, 3, 317, 5, 317, 6431, 10, 317, 3, 317, 5, 317, 6434, 10, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 5, 318, 6446, 10, 318, 3, 318, 3, 318, 3, 318, 5, 318, 6451, 10, 318, 3, 318, 7, 318, 6454, 10, 318, 12, 318, 14, 318, 6457, 11, 318, 3, 319, 3, 319, 3, 319, 5, 319, 6462, 10, 319, 3, 319, 3, 319, 3, 319, 3, 319, 3, 319, 5, 319, 6469, 10, 319, 3, 319, 5, 319, 6472, 10, 319, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 7, 320, 6481, 10, 320, 12, 320, 14, 320, 6484, 11, 320, 3, 320, 3, 320, 5, 320, 6488, 10, 320, 5, 320, 6490, 10, 320, 3, 320, 5, 320, 6493, 10, 320, 3, 320, 5, 320, 6496, 10, 320, 3, 320, 3, 320, 3, 320, 3, 320, 7, 320, 6502, 10, 320, 12, 320, 14, 320, 6505, 11, 320, 5, 320, 6507, 10, 320, 3, 320, 3, 320, 5, 320, 6511, 10, 320, 3, 320, 5, 320, 6514, 10, 320, 3, 320, 3, 320, 5, 320, 6518, 10, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 7, 320, 6529, 10, 320, 12, 320, 14, 320, 6532, 11, 320, 5, 320, 6534, 10, 320, 3, 320, 3, 320, 5, 320, 6538, 10, 320, 3, 320, 3, 320, 5, 320, 6542, 10, 320, 3, 320, 5, 320, 6545, 10, 320, 3, 321, 3, 321, 3, 321, 7, 321, 6550, 10, 321, 12, 321, 14, 321, 6553, 11, 321, 3, 322, 3, 322, 3, 322, 3, 322, 5, 322, 6559, 10, 322, 3, 323, 3, 323, 5, 323, 6563, 10, 323, 3, 323, 5, 323, 6566, 10, 323, 3, 323, 3, 323, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 5, 324, 6575, 10, 324, 3, 324, 5, 324, 6578, 10, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 5, 324, 6589, 10, 324, 5, 324, 6591, 10, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 5, 324, 6599, 10, 324, 5, 324, 6601, 10, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 5, 324, 6612, 10, 324, 5, 324, 6614, 10, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 7, 324, 6621, 10, 324, 12, 324, 14, 324, 6624, 11, 324, 3, 325, 5, 325, 6627, 10, 325, 3, 325, 3, 325, 5, 325, 6631, 10, 325, 3, 325, 5, 325, 6634, 10, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 7, 325, 6642, 10, 325, 12, 325, 14, 325, 6645, 11, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6650, 10, 325, 5, 325, 6652, 10, 325, 3, 325, 5, 325, 6655, 10, 325, 3, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6661, 10, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6666, 10, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6671, 10, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 7, 325, 6678, 10, 325, 12, 325, 14, 325, 6681, 11, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6686, 10, 325, 5, 325, 6688, 10, 325, 3, 325, 5, 325, 6691, 10, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6699, 10, 325, 3, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6705, 10, 325, 7, 325, 6707, 10, 325, 12, 325, 14, 325, 6710, 11, 325, 3, 325, 3, 325, 3, 325, 5, 325, 6715, 10, 325, 3, 325, 5, 325, 6718, 10, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 7, 325, 6725, 10, 325, 12, 325, 14, 325, 6728, 11, 325, 3, 325, 3, 325, 5, 325, 6732, 10, 325, 5, 325, 6734, 10, 325, 5, 325, 6736, 10, 325, 3, 326, 5, 326, 6739, 10, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 7, 326, 6746, 10, 326, 12, 326, 14, 326, 6749, 11, 326, 3, 326, 3, 326, 5, 326, 6753, 10, 326, 3, 327, 3, 327, 3, 327, 3, 327, 3, 327, 3, 327, 3, 327, 7, 327, 6762, 10, 327, 12, 327, 14, 327, 6765, 11, 327, 3, 327, 3, 327, 3, 328, 3, 328, 3, 328, 3, 328, 3, 329, 3, 329, 3, 329, 7, 329, 6776, 10, 329, 12, 329, 14, 329, 6779, 11, 329, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 5, 330, 6788, 10, 330, 3, 330, 3, 330, 3, 330, 3, 330, 5, 330, 6794, 10, 330, 3, 331, 3, 331, 3, 331, 3, 331, 7, 331, 6800, 10, 331, 12, 331, 14, 331, 6803, 11, 331, 3, 332, 3, 332, 3, 332, 5, 332, 6808, 10, 332, 3, 332, 3, 332, 3, 332, 5, 332, 6813, 10, 332, 7, 332, 6815, 10, 332, 12, 332, 14, 332, 6818, 11, 332, 3, 332, 3, 332, 3, 333, 3, 333, 3, 333, 3, 333, 3, 334, 3, 334, 3, 334, 7, 334, 6829, 10, 334, 12, 334, 14, 334, 6832, 11, 334, 3, 335, 3, 335, 5, 335, 6836, 10, 335, 3, 335, 5, 335, 6839, 10, 335, 3, 335, 5, 335, 6842, 10, 335, 3, 336, 3, 336, 3, 336, 3, 336, 5, 336, 6848, 10, 336, 3, 337, 3, 337, 3, 337, 3, 338, 5, 338, 6854, 10, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 5, 338, 6861, 10, 338, 3, 338, 3, 338, 3, 338, 5, 338, 6866, 10, 338, 3, 338, 5, 338, 6869, 10, 338, 3, 338, 3, 338, 3, 338, 5, 338, 6874, 10, 338, 3, 338, 3, 338, 3, 338, 5, 338, 6879, 10, 338, 3, 338, 5, 338, 6882, 10, 338, 3, 338, 3, 338, 5, 338, 6886, 10, 338, 3, 339, 3, 339, 3, 339, 3, 339, 7, 339, 6892, 10, 339, 12, 339, 14, 339, 6895, 11, 339, 3, 339, 3, 339, 3, 340, 3, 340, 5, 340, 6901, 10, 340, 3, 341, 3, 341, 5, 341, 6905, 10, 341, 3, 341, 3, 341, 3, 341, 5, 341, 6910, 10, 341, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 7, 342, 6920, 10, 342, 12, 342, 14, 342, 6923, 11, 342, 3, 342, 3, 342, 5, 342, 6927, 10, 342, 5, 342, 6929, 10, 342, 3, 343, 5, 343, 6932, 10, 343, 3, 343, 3, 343, 3, 343, 5, 343, 6937, 10, 343, 3, 343, 3, 343, 5, 343, 6941, 10, 343, 3, 343, 5, 343, 6944, 10, 343, 3, 343, 5, 343, 6947, 10, 343, 3, 343, 3, 343, 3, 343, 3, 343, 7, 343, 6953, 10, 343, 12, 343, 14, 343, 6956, 11, 343, 5, 343, 6958, 10, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 5, 343, 6965, 10, 343, 5, 343, 6967, 10, 343, 3, 343, 3, 343, 5, 343, 6971, 10, 343, 3, 344, 5, 344, 6974, 10, 344, 3, 344, 3, 344, 5, 344, 6978, 10, 344, 3, 344, 3, 344, 5, 344, 6982, 10, 344, 3, 344, 5, 344, 6985, 10, 344, 3, 344, 5, 344, 6988, 10, 344, 3, 344, 3, 344, 3, 344, 3, 344, 7, 344, 6994, 10, 344, 12, 344, 14, 344, 6997, 11, 344, 3, 344, 3, 344, 3, 344, 3, 344, 7, 344, 7003, 10, 344, 12, 344, 14, 344, 7006, 11, 344, 5, 344, 7008, 10, 344, 3, 344, 3, 344, 3, 344, 3, 344, 3, 344, 5, 344, 7015, 10, 344, 5, 344, 7017, 10, 344, 3, 344, 3, 344, 5, 344, 7021, 10, 344, 3, 345, 3, 345, 3, 345, 3, 345, 5, 345, 7027, 10, 345, 3, 345, 3, 345, 3, 345, 3, 345, 7, 345, 7033, 10, 345, 12, 345, 14, 345, 7036, 11, 345, 3, 345, 3, 345, 3, 345, 5, 345, 7041, 10, 345, 3, 345, 3, 345, 3, 345, 5, 345, 7046, 10, 345, 3, 345, 3, 345, 3, 345, 5, 345, 7051, 10, 345, 7, 345, 7053, 10, 345, 12, 345, 14, 345, 7056, 11, 345, 3, 345, 3, 345, 5, 345, 7060, 10, 345, 5, 345, 7062, 10, 345, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 7068, 10, 346, 3, 347, 3, 347, 5, 347, 7072, 10, 347, 3, 347, 3, 347, 3, 347, 7, 347, 7077, 10, 347, 12, 347, 14, 347, 7080, 11, 347, 3, 347, 3, 347, 5, 347, 7084, 10, 347, 3, 347, 5, 347, 7087, 10, 347, 3, 348, 3, 348, 3, 348, 7, 348, 7092, 10, 348, 12, 348, 14, 348, 7095, 11, 348, 3, 349, 3, 349, 3, 349, 3, 349, 5, 349, 7101, 10, 349, 5, 349, 7103, 10, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 5, 349, 7111, 10, 349, 5, 349, 7113, 10, 349, 3, 350, 3, 350, 3, 350, 3, 350, 5, 350, 7119, 10, 350, 3, 351, 5, 351, 7122, 10, 351, 3, 351, 5, 351, 7125, 10, 351, 3, 351, 3, 351, 3, 351, 5, 351, 7130, 10, 351, 3, 351, 3, 351, 5, 351, 7134, 10, 351, 3, 352, 3, 352, 3, 352, 3, 352, 3, 353, 3, 353, 7, 353, 7142, 10, 353, 12, 353, 14, 353, 7145, 11, 353, 3, 354, 7, 354, 7148, 10, 354, 12, 354, 14, 354, 7151, 11, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 355, 5, 355, 7158, 10, 355, 3, 355, 3, 355, 5, 355, 7162, 10, 355, 3, 355, 3, 355, 5, 355, 7166, 10, 355, 3, 355, 3, 355, 5, 355, 7170, 10, 355, 3, 355, 3, 355, 3, 355, 3, 355, 5, 355, 7176, 10, 355, 3, 355, 5, 355, 7179, 10, 355, 3, 355, 5, 355, 7182, 10, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 5, 355, 7189, 10, 355, 3, 355, 3, 355, 5, 355, 7193, 10, 355, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 7, 356, 7201, 10, 356, 12, 356, 14, 356, 7204, 11, 356, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 5, 357, 7215, 10, 357, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 6, 358, 7223, 10, 358, 13, 358, 14, 358, 7224, 3, 359, 3, 359, 3, 359, 7, 359, 7230, 10, 359, 12, 359, 14, 359, 7233, 11, 359, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 5, 360, 7244, 10, 360, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 5, 361, 7251, 10, 361, 3, 361, 3, 361, 3, 361, 3, 361, 7, 361, 7257, 10, 361, 12, 361, 14, 361, 7260, 11, 361, 3, 361, 5, 361, 7263, 10, 361, 3, 362, 3, 362, 5, 362, 7267, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 7, 362, 7273, 10, 362, 12, 362, 14, 362, 7276, 11, 362, 3, 363, 3, 363, 3, 363, 3, 363, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 7, 364, 7288, 10, 364, 12, 364, 14, 364, 7291, 11, 364, 3, 364, 3, 364, 5, 364, 7295, 10, 364, 5, 364, 7297, 10, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 7, 364, 7304, 10, 364, 12, 364, 14, 364, 7307, 11, 364, 5, 364, 7309, 10, 364, 3, 364, 3, 364, 5, 364, 7313, 10, 364, 3, 364, 5, 364, 7316, 10, 364, 3, 364, 3, 364, 5, 364, 7320, 10, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 7, 364, 7331, 10, 364, 12, 364, 14, 364, 7334, 11, 364, 5, 364, 7336, 10, 364, 3, 364, 3, 364, 5, 364, 7340, 10, 364, 3, 364, 5, 364, 7343, 10, 364, 3, 364, 7, 364, 7346, 10, 364, 12, 364, 14, 364, 7349, 11, 364, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 7355, 10, 365, 3, 366, 3, 366, 3, 366, 5, 366, 7360, 10, 366, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 5, 367, 7368, 10, 367, 3, 368, 3, 368, 3, 368, 5, 368, 7373, 10, 368, 3, 368, 5, 368, 7376, 10, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 7, 368, 7387, 10, 368, 12, 368, 14, 368, 7390, 11, 368, 3, 368, 3, 368, 5, 368, 7394, 10, 368, 3, 368, 3, 368, 5, 368, 7398, 10, 368, 3, 368, 5, 368, 7401, 10, 368, 3, 368, 3, 368, 3, 368, 5, 368, 7406, 10, 368, 3, 368, 5, 368, 7409, 10, 368, 3, 368, 3, 368, 3, 368, 5, 368, 7414, 10, 368, 3, 369, 3, 369, 3, 369, 5, 369, 7419, 10, 369, 3, 369, 3, 369, 3, 370, 3, 370, 3, 370, 5, 370, 7426, 10, 370, 3, 370, 5, 370, 7429, 10, 370, 3, 370, 5, 370, 7432, 10, 370, 3, 371, 3, 371, 5, 371, 7436, 10, 371, 3, 371, 3, 371, 3, 371, 7, 371, 7441, 10, 371, 12, 371, 14, 371, 7444, 11, 371, 5, 371, 7446, 10, 371, 3, 371, 5, 371, 7449, 10, 371, 3, 371, 3, 371, 5, 371, 7453, 10, 371, 3, 371, 3, 371, 5, 371, 7457, 10, 371, 3, 371, 3, 371, 5, 371, 7461, 10, 371, 3, 371, 3, 371, 3, 371, 5, 371, 7466, 10, 371, 3, 371, 3, 371, 3, 371, 3, 371, 5, 371, 7472, 10, 371, 5, 371, 7474, 10, 371, 3, 372, 3, 372, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 7, 373, 7487, 10, 373, 12, 373, 14, 373, 7490, 11, 373, 3, 374, 3, 374, 3, 375, 3, 375, 5, 375, 7496, 10, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 5, 375, 7504, 10, 375, 3, 376, 5, 376, 7507, 10, 376, 3, 376, 5, 376, 7510, 10, 376, 3, 376, 3, 376, 3, 376, 3, 376, 3, 376, 5, 376, 7517, 10, 376, 3, 376, 3, 376, 5, 376, 7521, 10, 376, 3, 376, 3, 376, 5, 376, 7525, 10, 376, 5, 376, 7527, 10, 376, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 7535, 10, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 7542, 10, 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, 7, 377, 7557, 10, 377, 12, 377, 14, 377, 7560, 11, 377, 3, 377, 3, 377, 5, 377, 7564, 10, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 7570, 10, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 7576, 10, 377, 3, 378, 3, 378, 3, 378, 3, 378, 7, 378, 7582, 10, 378, 12, 378, 14, 378, 7585, 11, 378, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 7, 379, 7596, 10, 379, 12, 379, 14, 379, 7599, 11, 379, 3, 379, 3, 379, 5, 379, 7603, 10, 379, 3, 379, 3, 379, 3, 379, 3, 380, 3, 380, 5, 380, 7610, 10, 380, 3, 380, 3, 380, 3, 380, 3, 380, 7, 380, 7616, 10, 380, 12, 380, 14, 380, 7619, 11, 380, 3, 380, 3, 380, 3, 380, 6, 380, 7624, 10, 380, 13, 380, 14, 380, 7625, 3, 380, 3, 380, 5, 380, 7630, 10, 380, 3, 380, 3, 380, 3, 380, 3, 381, 3, 381, 3, 381, 3, 381, 5, 381, 7639, 10, 381, 3, 381, 2, 6, 560, 562, 634, 646, 382, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 2, 109, 4, 2, 260, 260, 288, 288, 6, 2, 3, 3, 38, 38, 212, 212, 397, 397, 4, 2, 5, 5, 324, 324, 4, 2, 274, 274, 324, 324, 4, 2, 147, 147, 400, 400, 4, 2, 403, 403, 407, 407, 7, 2, 177, 177, 226, 226, 255, 255, 257, 257, 368, 368, 7, 2, 55, 55, 113, 113, 219, 219, 252, 252, 431, 431, 4, 2, 287, 287, 444, 444, 9, 2, 367, 367, 370, 370, 447, 447, 455, 455, 525, 525, 535, 535, 537, 537, 6, 2, 258, 258, 291, 291, 479, 479, 543, 543, 9, 2, 263, 263, 351, 352, 367, 367, 370, 370, 460, 460, 475, 475, 528, 528, 4, 2, 367, 367, 528, 528, 7, 2, 159, 159, 399, 399, 419, 419, 435, 435, 610, 610, 4, 2, 4, 4, 200, 200, 4, 2, 368, 368, 610, 610, 4, 2, 94, 94, 186, 186, 4, 2, 7, 7, 73, 73, 4, 2, 68, 68, 75, 75, 4, 2, 13, 13, 205, 205, 4, 2, 34, 34, 160, 160, 4, 2, 137, 137, 272, 272, 6, 2, 87, 87, 462, 462, 488, 488, 511, 511, 4, 2, 60, 60, 106, 106, 4, 2, 61, 61, 122, 122, 5, 2, 519, 519, 522, 522, 540, 540, 4, 2, 433, 433, 578, 578, 4, 2, 211, 211, 438, 438, 4, 2, 9, 9, 20, 20, 4, 2, 73, 73, 230, 230, 6, 2, 40, 40, 67, 67, 172, 172, 256, 256, 4, 2, 7, 7, 12, 12, 6, 2, 281, 281, 480, 481, 486, 486, 513, 513, 5, 2, 10, 10, 94, 94, 186, 186, 4, 2, 208, 208, 357, 357, 4, 2, 113, 113, 431, 431, 4, 2, 482, 482, 521, 521, 4, 2, 453, 453, 499, 499, 4, 2, 514, 515, 527, 527, 4, 2, 133, 133, 229, 229, 4, 2, 44, 44, 70, 70, 6, 2, 62, 62, 120, 120, 274, 274, 427, 427, 4, 2, 11, 11, 121, 121, 4, 2, 241, 241, 324, 324, 4, 2, 150, 150, 161, 161, 4, 2, 403, 403, 433, 433, 5, 2, 94, 94, 186, 186, 214, 214, 7, 2, 95, 95, 187, 187, 215, 215, 226, 226, 253, 253, 6, 2, 10, 10, 94, 94, 186, 186, 214, 214, 4, 2, 32, 32, 88, 88, 4, 2, 391, 391, 578, 578, 6, 2, 309, 309, 319, 319, 407, 407, 440, 440, 4, 2, 255, 255, 257, 257, 5, 2, 296, 296, 311, 311, 326, 326, 3, 2, 589, 590, 4, 2, 510, 510, 520, 520, 7, 2, 62, 62, 120, 120, 274, 274, 368, 368, 427, 427, 4, 2, 94, 94, 162, 162, 5, 2, 7, 7, 73, 73, 230, 230, 5, 2, 49, 49, 258, 258, 346, 346, 4, 2, 27, 27, 133, 133, 4, 2, 97, 97, 133, 133, 5, 2, 191, 191, 471, 471, 485, 485, 4, 2, 82, 82, 111, 111, 10, 2, 37, 37, 43, 43, 59, 59, 96, 96, 104, 104, 114, 114, 245, 245, 368, 368, 5, 2, 173, 173, 234, 234, 352, 352, 4, 2, 62, 62, 274, 274, 5, 2, 603, 604, 606, 606, 609, 609, 4, 2, 391, 391, 417, 417, 5, 2, 274, 274, 427, 427, 541, 541, 4, 2, 26, 26, 208, 208, 3, 2, 3, 294, 3, 2, 295, 344, 3, 2, 345, 367, 3, 2, 368, 444, 3, 2, 445, 576, 3, 2, 299, 300, 3, 2, 591, 593, 4, 2, 376, 376, 430, 430, 4, 2, 578, 578, 582, 586, 3, 2, 610, 611, 5, 2, 399, 399, 419, 419, 435, 435, 4, 2, 330, 330, 379, 379, 3, 2, 601, 602, 7, 2, 301, 301, 307, 308, 313, 313, 317, 317, 335, 335, 5, 2, 377, 377, 412, 412, 434, 434, 5, 2, 368, 368, 372, 372, 429, 429, 5, 2, 99, 99, 191, 191, 216, 216, 4, 2, 91, 91, 179, 179, 4, 2, 368, 368, 394, 394, 4, 2, 216, 216, 324, 324, 4, 2, 90, 90, 151, 151, 5, 2, 398, 398, 409, 409, 436, 436, 5, 2, 255, 255, 257, 257, 272, 272, 5, 2, 352, 352, 358, 358, 364, 364, 4, 2, 90, 90, 128, 128, 4, 2, 252, 252, 438, 438, 4, 2, 45, 45, 207, 207, 5, 2, 391, 391, 578, 578, 602, 602, 4, 2, 355, 355, 401, 401, 4, 2, 51, 51, 574, 574, 4, 2, 578, 578, 602, 602, 4, 2, 38, 38, 212, 212, 7, 2, 548, 548, 555, 555, 559, 560, 563, 563, 575, 575, 10, 2, 219, 219, 382, 383, 431, 431, 547, 547, 549, 549, 553, 553, 558, 558, 562, 562, 4, 2, 45, 45, 554, 554, 3, 2, 551, 552, 2, 8974, 2, 763, 3, 2, 2, 2, 4, 787, 3, 2, 2, 2, 6, 791, 3, 2, 2, 2, 8, 796, 3, 2, 2, 2, 10, 807, 3, 2, 2, 2, 12, 823, 3, 2, 2, 2, 14, 831, 3, 2, 2, 2, 16, 837, 3, 2, 2, 2, 18, 841, 3, 2, 2, 2, 20, 900, 3, 2, 2, 2, 22, 921, 3, 2, 2, 2, 24, 923, 3, 2, 2, 2, 26, 956, 3, 2, 2, 2, 28, 985, 3, 2, 2, 2, 30, 1113, 3, 2, 2, 2, 32, 1115, 3, 2, 2, 2, 34, 1145, 3, 2, 2, 2, 36, 1147, 3, 2, 2, 2, 38, 1162, 3, 2, 2, 2, 40, 1184, 3, 2, 2, 2, 42, 1207, 3, 2, 2, 2, 44, 1212, 3, 2, 2, 2, 46, 1214, 3, 2, 2, 2, 48, 1222, 3, 2, 2, 2, 50, 1259, 3, 2, 2, 2, 52, 1261, 3, 2, 2, 2, 54, 1265, 3, 2, 2, 2, 56, 1269, 3, 2, 2, 2, 58, 1288, 3, 2, 2, 2, 60, 1293, 3, 2, 2, 2, 62, 1341, 3, 2, 2, 2, 64, 1343, 3, 2, 2, 2, 66, 1378, 3, 2, 2, 2, 68, 1392, 3, 2, 2, 2, 70, 1415, 3, 2, 2, 2, 72, 1445, 3, 2, 2, 2, 74, 1451, 3, 2, 2, 2, 76, 1466, 3, 2, 2, 2, 78, 1558, 3, 2, 2, 2, 80, 1560, 3, 2, 2, 2, 82, 1565, 3, 2, 2, 2, 84, 1574, 3, 2, 2, 2, 86, 1731, 3, 2, 2, 2, 88, 1777, 3, 2, 2, 2, 90, 1779, 3, 2, 2, 2, 92, 1813, 3, 2, 2, 2, 94, 1815, 3, 2, 2, 2, 96, 1817, 3, 2, 2, 2, 98, 1821, 3, 2, 2, 2, 100, 1831, 3, 2, 2, 2, 102, 1835, 3, 2, 2, 2, 104, 1894, 3, 2, 2, 2, 106, 1896, 3, 2, 2, 2, 108, 1924, 3, 2, 2, 2, 110, 1965, 3, 2, 2, 2, 112, 1967, 3, 2, 2, 2, 114, 1986, 3, 2, 2, 2, 116, 2049, 3, 2, 2, 2, 118, 2053, 3, 2, 2, 2, 120, 2076, 3, 2, 2, 2, 122, 2100, 3, 2, 2, 2, 124, 2112, 3, 2, 2, 2, 126, 2114, 3, 2, 2, 2, 128, 2152, 3, 2, 2, 2, 130, 2177, 3, 2, 2, 2, 132, 2190, 3, 2, 2, 2, 134, 2192, 3, 2, 2, 2, 136, 2242, 3, 2, 2, 2, 138, 2278, 3, 2, 2, 2, 140, 2280, 3, 2, 2, 2, 142, 2284, 3, 2, 2, 2, 144, 2288, 3, 2, 2, 2, 146, 2309, 3, 2, 2, 2, 148, 2324, 3, 2, 2, 2, 150, 2328, 3, 2, 2, 2, 152, 2340, 3, 2, 2, 2, 154, 2343, 3, 2, 2, 2, 156, 2374, 3, 2, 2, 2, 158, 2396, 3, 2, 2, 2, 160, 2427, 3, 2, 2, 2, 162, 2578, 3, 2, 2, 2, 164, 2593, 3, 2, 2, 2, 166, 2613, 3, 2, 2, 2, 168, 2630, 3, 2, 2, 2, 170, 2634, 3, 2, 2, 2, 172, 2649, 3, 2, 2, 2, 174, 2672, 3, 2, 2, 2, 176, 2707, 3, 2, 2, 2, 178, 2728, 3, 2, 2, 2, 180, 2746, 3, 2, 2, 2, 182, 2748, 3, 2, 2, 2, 184, 2763, 3, 2, 2, 2, 186, 2775, 3, 2, 2, 2, 188, 2793, 3, 2, 2, 2, 190, 2831, 3, 2, 2, 2, 192, 2833, 3, 2, 2, 2, 194, 2844, 3, 2, 2, 2, 196, 2846, 3, 2, 2, 2, 198, 2879, 3, 2, 2, 2, 200, 2902, 3, 2, 2, 2, 202, 2904, 3, 2, 2, 2, 204, 2911, 3, 2, 2, 2, 206, 2934, 3, 2, 2, 2, 208, 2936, 3, 2, 2, 2, 210, 2953, 3, 2, 2, 2, 212, 2955, 3, 2, 2, 2, 214, 2959, 3, 2, 2, 2, 216, 2972, 3, 2, 2, 2, 218, 2985, 3, 2, 2, 2, 220, 3000, 3, 2, 2, 2, 222, 3015, 3, 2, 2, 2, 224, 3030, 3, 2, 2, 2, 226, 3051, 3, 2, 2, 2, 228, 3059, 3, 2, 2, 2, 230, 3076, 3, 2, 2, 2, 232, 3080, 3, 2, 2, 2, 234, 3103, 3, 2, 2, 2, 236, 3112, 3, 2, 2, 2, 238, 3126, 3, 2, 2, 2, 240, 3128, 3, 2, 2, 2, 242, 3142, 3, 2, 2, 2, 244, 3144, 3, 2, 2, 2, 246, 3166, 3, 2, 2, 2, 248, 3184, 3, 2, 2, 2, 250, 3214, 3, 2, 2, 2, 252, 3217, 3, 2, 2, 2, 254, 3233, 3, 2, 2, 2, 256, 3254, 3, 2, 2, 2, 258, 3258, 3, 2, 2, 2, 260, 3340, 3, 2, 2, 2, 262, 3342, 3, 2, 2, 2, 264, 3382, 3, 2, 2, 2, 266, 3413, 3, 2, 2, 2, 268, 3424, 3, 2, 2, 2, 270, 3428, 3, 2, 2, 2, 272, 3469, 3, 2, 2, 2, 274, 3472, 3, 2, 2, 2, 276, 3534, 3, 2, 2, 2, 278, 3541, 3, 2, 2, 2, 280, 3568, 3, 2, 2, 2, 282, 3619, 3, 2, 2, 2, 284, 3621, 3, 2, 2, 2, 286, 3629, 3, 2, 2, 2, 288, 3634, 3, 2, 2, 2, 290, 3658, 3, 2, 2, 2, 292, 3681, 3, 2, 2, 2, 294, 3683, 3, 2, 2, 2, 296, 3690, 3, 2, 2, 2, 298, 3695, 3, 2, 2, 2, 300, 3704, 3, 2, 2, 2, 302, 3708, 3, 2, 2, 2, 304, 3716, 3, 2, 2, 2, 306, 3856, 3, 2, 2, 2, 308, 3903, 3, 2, 2, 2, 310, 3907, 3, 2, 2, 2, 312, 3921, 3, 2, 2, 2, 314, 3928, 3, 2, 2, 2, 316, 3932, 3, 2, 2, 2, 318, 3944, 3, 2, 2, 2, 320, 3947, 3, 2, 2, 2, 322, 3950, 3, 2, 2, 2, 324, 3969, 3, 2, 2, 2, 326, 3988, 3, 2, 2, 2, 328, 3991, 3, 2, 2, 2, 330, 4001, 3, 2, 2, 2, 332, 4004, 3, 2, 2, 2, 334, 4053, 3, 2, 2, 2, 336, 4056, 3, 2, 2, 2, 338, 4061, 3, 2, 2, 2, 340, 4065, 3, 2, 2, 2, 342, 4067, 3, 2, 2, 2, 344, 4078, 3, 2, 2, 2, 346, 4140, 3, 2, 2, 2, 348, 4142, 3, 2, 2, 2, 350, 4152, 3, 2, 2, 2, 352, 4161, 3, 2, 2, 2, 354, 4184, 3, 2, 2, 2, 356, 4186, 3, 2, 2, 2, 358, 4209, 3, 2, 2, 2, 360, 4221, 3, 2, 2, 2, 362, 4227, 3, 2, 2, 2, 364, 4255, 3, 2, 2, 2, 366, 4287, 3, 2, 2, 2, 368, 4289, 3, 2, 2, 2, 370, 4305, 3, 2, 2, 2, 372, 4316, 3, 2, 2, 2, 374, 4385, 3, 2, 2, 2, 376, 4387, 3, 2, 2, 2, 378, 4397, 3, 2, 2, 2, 380, 4409, 3, 2, 2, 2, 382, 4420, 3, 2, 2, 2, 384, 4427, 3, 2, 2, 2, 386, 4447, 3, 2, 2, 2, 388, 4465, 3, 2, 2, 2, 390, 4468, 3, 2, 2, 2, 392, 4474, 3, 2, 2, 2, 394, 4485, 3, 2, 2, 2, 396, 4493, 3, 2, 2, 2, 398, 4495, 3, 2, 2, 2, 400, 4521, 3, 2, 2, 2, 402, 4549, 3, 2, 2, 2, 404, 4619, 3, 2, 2, 2, 406, 4623, 3, 2, 2, 2, 408, 4665, 3, 2, 2, 2, 410, 4668, 3, 2, 2, 2, 412, 4672, 3, 2, 2, 2, 414, 4683, 3, 2, 2, 2, 416, 4695, 3, 2, 2, 2, 418, 4724, 3, 2, 2, 2, 420, 4760, 3, 2, 2, 2, 422, 4775, 3, 2, 2, 2, 424, 4777, 3, 2, 2, 2, 426, 4789, 3, 2, 2, 2, 428, 4816, 3, 2, 2, 2, 430, 4818, 3, 2, 2, 2, 432, 4829, 3, 2, 2, 2, 434, 4845, 3, 2, 2, 2, 436, 4850, 3, 2, 2, 2, 438, 4854, 3, 2, 2, 2, 440, 4866, 3, 2, 2, 2, 442, 4870, 3, 2, 2, 2, 444, 4875, 3, 2, 2, 2, 446, 4888, 3, 2, 2, 2, 448, 4896, 3, 2, 2, 2, 450, 4898, 3, 2, 2, 2, 452, 4919, 3, 2, 2, 2, 454, 4933, 3, 2, 2, 2, 456, 4935, 3, 2, 2, 2, 458, 4949, 3, 2, 2, 2, 460, 4954, 3, 2, 2, 2, 462, 5040, 3, 2, 2, 2, 464, 5055, 3, 2, 2, 2, 466, 5070, 3, 2, 2, 2, 468, 5072, 3, 2, 2, 2, 470, 5075, 3, 2, 2, 2, 472, 5088, 3, 2, 2, 2, 474, 5092, 3, 2, 2, 2, 476, 5100, 3, 2, 2, 2, 478, 5111, 3, 2, 2, 2, 480, 5116, 3, 2, 2, 2, 482, 5121, 3, 2, 2, 2, 484, 5129, 3, 2, 2, 2, 486, 5131, 3, 2, 2, 2, 488, 5140, 3, 2, 2, 2, 490, 5148, 3, 2, 2, 2, 492, 5150, 3, 2, 2, 2, 494, 5157, 3, 2, 2, 2, 496, 5161, 3, 2, 2, 2, 498, 5176, 3, 2, 2, 2, 500, 5178, 3, 2, 2, 2, 502, 5180, 3, 2, 2, 2, 504, 5190, 3, 2, 2, 2, 506, 5192, 3, 2, 2, 2, 508, 5197, 3, 2, 2, 2, 510, 5202, 3, 2, 2, 2, 512, 5217, 3, 2, 2, 2, 514, 5234, 3, 2, 2, 2, 516, 5236, 3, 2, 2, 2, 518, 5247, 3, 2, 2, 2, 520, 5257, 3, 2, 2, 2, 522, 5309, 3, 2, 2, 2, 524, 5314, 3, 2, 2, 2, 526, 5323, 3, 2, 2, 2, 528, 5328, 3, 2, 2, 2, 530, 5333, 3, 2, 2, 2, 532, 5340, 3, 2, 2, 2, 534, 5342, 3, 2, 2, 2, 536, 5344, 3, 2, 2, 2, 538, 5346, 3, 2, 2, 2, 540, 5348, 3, 2, 2, 2, 542, 5350, 3, 2, 2, 2, 544, 5357, 3, 2, 2, 2, 546, 5359, 3, 2, 2, 2, 548, 5368, 3, 2, 2, 2, 550, 5382, 3, 2, 2, 2, 552, 5479, 3, 2, 2, 2, 554, 5508, 3, 2, 2, 2, 556, 5510, 3, 2, 2, 2, 558, 5514, 3, 2, 2, 2, 560, 5547, 3, 2, 2, 2, 562, 5710, 3, 2, 2, 2, 564, 5776, 3, 2, 2, 2, 566, 5786, 3, 2, 2, 2, 568, 5788, 3, 2, 2, 2, 570, 5818, 3, 2, 2, 2, 572, 5823, 3, 2, 2, 2, 574, 5825, 3, 2, 2, 2, 576, 5827, 3, 2, 2, 2, 578, 5829, 3, 2, 2, 2, 580, 5848, 3, 2, 2, 2, 582, 5898, 3, 2, 2, 2, 584, 5901, 3, 2, 2, 2, 586, 5910, 3, 2, 2, 2, 588, 5937, 3, 2, 2, 2, 590, 5939, 3, 2, 2, 2, 592, 5955, 3, 2, 2, 2, 594, 5974, 3, 2, 2, 2, 596, 6043, 3, 2, 2, 2, 598, 6206, 3, 2, 2, 2, 600, 6208, 3, 2, 2, 2, 602, 6228, 3, 2, 2, 2, 604, 6236, 3, 2, 2, 2, 606, 6242, 3, 2, 2, 2, 608, 6257, 3, 2, 2, 2, 610, 6282, 3, 2, 2, 2, 612, 6284, 3, 2, 2, 2, 614, 6289, 3, 2, 2, 2, 616, 6317, 3, 2, 2, 2, 618, 6319, 3, 2, 2, 2, 620, 6328, 3, 2, 2, 2, 622, 6330, 3, 2, 2, 2, 624, 6335, 3, 2, 2, 2, 626, 6390, 3, 2, 2, 2, 628, 6393, 3, 2, 2, 2, 630, 6402, 3, 2, 2, 2, 632, 6414, 3, 2, 2, 2, 634, 6445, 3, 2, 2, 2, 636, 6471, 3, 2, 2, 2, 638, 6544, 3, 2, 2, 2, 640, 6546, 3, 2, 2, 2, 642, 6554, 3, 2, 2, 2, 644, 6560, 3, 2, 2, 2, 646, 6577, 3, 2, 2, 2, 648, 6735, 3, 2, 2, 2, 650, 6738, 3, 2, 2, 2, 652, 6754, 3, 2, 2, 2, 654, 6768, 3, 2, 2, 2, 656, 6772, 3, 2, 2, 2, 658, 6793, 3, 2, 2, 2, 660, 6795, 3, 2, 2, 2, 662, 6804, 3, 2, 2, 2, 664, 6821, 3, 2, 2, 2, 666, 6825, 3, 2, 2, 2, 668, 6833, 3, 2, 2, 2, 670, 6847, 3, 2, 2, 2, 672, 6849, 3, 2, 2, 2, 674, 6853, 3, 2, 2, 2, 676, 6887, 3, 2, 2, 2, 678, 6898, 3, 2, 2, 2, 680, 6909, 3, 2, 2, 2, 682, 6928, 3, 2, 2, 2, 684, 6931, 3, 2, 2, 2, 686, 6973, 3, 2, 2, 2, 688, 7061, 3, 2, 2, 2, 690, 7063, 3, 2, 2, 2, 692, 7069, 3, 2, 2, 2, 694, 7088, 3, 2, 2, 2, 696, 7112, 3, 2, 2, 2, 698, 7114, 3, 2, 2, 2, 700, 7121, 3, 2, 2, 2, 702, 7135, 3, 2, 2, 2, 704, 7139, 3, 2, 2, 2, 706, 7149, 3, 2, 2, 2, 708, 7192, 3, 2, 2, 2, 710, 7194, 3, 2, 2, 2, 712, 7214, 3, 2, 2, 2, 714, 7216, 3, 2, 2, 2, 716, 7231, 3, 2, 2, 2, 718, 7243, 3, 2, 2, 2, 720, 7262, 3, 2, 2, 2, 722, 7266, 3, 2, 2, 2, 724, 7277, 3, 2, 2, 2, 726, 7296, 3, 2, 2, 2, 728, 7350, 3, 2, 2, 2, 730, 7356, 3, 2, 2, 2, 732, 7367, 3, 2, 2, 2, 734, 7413, 3, 2, 2, 2, 736, 7418, 3, 2, 2, 2, 738, 7431, 3, 2, 2, 2, 740, 7473, 3, 2, 2, 2, 742, 7475, 3, 2, 2, 2, 744, 7477, 3, 2, 2, 2, 746, 7491, 3, 2, 2, 2, 748, 7503, 3, 2, 2, 2, 750, 7526, 3, 2, 2, 2, 752, 7575, 3, 2, 2, 2, 754, 7577, 3, 2, 2, 2, 756, 7586, 3, 2, 2, 2, 758, 7607, 3, 2, 2, 2, 760, 7638, 3, 2, 2, 2, 762, 764, 7, 621, 2, 2, 763, 762, 3, 2, 2, 2, 763, 764, 3, 2, 2, 2, 764, 768, 3, 2, 2, 2, 765, 767, 7, 580, 2, 2, 766, 765, 3, 2, 2, 2, 767, 770, 3, 2, 2, 2, 768, 766, 3, 2, 2, 2, 768, 769, 3, 2, 2, 2, 769, 782, 3, 2, 2, 2, 770, 768, 3, 2, 2, 2, 771, 778, 5, 14, 8, 2, 772, 774, 7, 580, 2, 2, 773, 772, 3, 2, 2, 2, 774, 775, 3, 2, 2, 2, 775, 773, 3, 2, 2, 2, 775, 776, 3, 2, 2, 2, 776, 779, 3, 2, 2, 2, 777, 779, 7, 2, 2, 3, 778, 773, 3, 2, 2, 2, 778, 777, 3, 2, 2, 2, 779, 781, 3, 2, 2, 2, 780, 771, 3, 2, 2, 2, 781, 784, 3, 2, 2, 2, 782, 780, 3, 2, 2, 2, 782, 783, 3, 2, 2, 2, 783, 785, 3, 2, 2, 2, 784, 782, 3, 2, 2, 2, 785, 786, 7, 2, 2, 3, 786, 3, 3, 2, 2, 2, 787, 788, 5, 618, 310, 2, 788, 789, 7, 2, 2, 3, 789, 5, 3, 2, 2, 2, 790, 792, 5, 618, 310, 2, 791, 790, 3, 2, 2, 2, 791, 792, 3, 2, 2, 2, 792, 793, 3, 2, 2, 2, 793, 794, 5, 322, 162, 2, 794, 795, 7, 2, 2, 3, 795, 7, 3, 2, 2, 2, 796, 801, 5, 560, 281, 2, 797, 798, 7, 581, 2, 2, 798, 800, 5, 560, 281, 2, 799, 797, 3, 2, 2, 2, 800, 803, 3, 2, 2, 2, 801, 799, 3, 2, 2, 2, 801, 802, 3, 2, 2, 2, 802, 804, 3, 2, 2, 2, 803, 801, 3, 2, 2, 2, 804, 805, 7, 2, 2, 3, 805, 9, 3, 2, 2, 2, 806, 808, 5, 698, 350, 2, 807, 806, 3, 2, 2, 2, 807, 808, 3, 2, 2, 2, 808, 809, 3, 2, 2, 2, 809, 811, 5, 700, 351, 2, 810, 812, 7, 580, 2, 2, 811, 810, 3, 2, 2, 2, 811, 812, 3, 2, 2, 2, 812, 813, 3, 2, 2, 2, 813, 814, 7, 2, 2, 3, 814, 11, 3, 2, 2, 2, 815, 817, 5, 698, 350, 2, 816, 815, 3, 2, 2, 2, 816, 817, 3, 2, 2, 2, 817, 818, 3, 2, 2, 2, 818, 819, 5, 700, 351, 2, 819, 820, 7, 580, 2, 2, 820, 822, 3, 2, 2, 2, 821, 816, 3, 2, 2, 2, 822, 825, 3, 2, 2, 2, 823, 821, 3, 2, 2, 2, 823, 824, 3, 2, 2, 2, 824, 826, 3, 2, 2, 2, 825, 823, 3, 2, 2, 2, 826, 827, 7, 2, 2, 3, 827, 13, 3, 2, 2, 2, 828, 832, 5, 16, 9, 2, 829, 832, 5, 60, 31, 2, 830, 832, 5, 18, 10, 2, 831, 828, 3, 2, 2, 2, 831, 829, 3, 2, 2, 2, 831, 830, 3, 2, 2, 2, 832, 15, 3, 2, 2, 2, 833, 838, 5, 624, 313, 2, 834, 838, 5, 674, 338, 2, 835, 838, 5, 686, 344, 2, 836, 838, 5, 684, 343, 2, 837, 833, 3, 2, 2, 2, 837, 834, 3, 2, 2, 2, 837, 835, 3, 2, 2, 2, 837, 836, 3, 2, 2, 2, 838, 17, 3, 2, 2, 2, 839, 842, 5, 20, 11, 2, 840, 842, 5, 28, 15, 2, 841, 839, 3, 2, 2, 2, 841, 840, 3, 2, 2, 2, 842, 19, 3, 2, 2, 2, 843, 844, 7, 240, 2, 2, 844, 850, 7, 260, 2, 2, 845, 847, 7, 21, 2, 2, 846, 848, 9, 2, 2, 2, 847, 846, 3, 2, 2, 2, 847, 848, 3, 2, 2, 2, 848, 850, 3, 2, 2, 2, 849, 843, 3, 2, 2, 2, 849, 845, 3, 2, 2, 2, 850, 859, 3, 2, 2, 2, 851, 856, 5, 22, 12, 2, 852, 853, 7, 581, 2, 2, 853, 855, 5, 22, 12, 2, 854, 852, 3, 2, 2, 2, 855, 858, 3, 2, 2, 2, 856, 854, 3, 2, 2, 2, 856, 857, 3, 2, 2, 2, 857, 860, 3, 2, 2, 2, 858, 856, 3, 2, 2, 2, 859, 851, 3, 2, 2, 2, 859, 860, 3, 2, 2, 2, 860, 901, 3, 2, 2, 2, 861, 863, 9, 3, 2, 2, 862, 864, 9, 2, 2, 2, 863, 862, 3, 2, 2, 2, 863, 864, 3, 2, 2, 2, 864, 870, 3, 2, 2, 2, 865, 867, 7, 371, 2, 2, 866, 868, 7, 152, 2, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 869, 3, 2, 2, 2, 869, 871, 7, 29, 2, 2, 870, 865, 3, 2, 2, 2, 870, 871, 3, 2, 2, 2, 871, 901, 3, 2, 2, 2, 872, 873, 7, 38, 2, 2, 873, 877, 7, 181, 2, 2, 874, 875, 7, 180, 2, 2, 875, 877, 7, 260, 2, 2, 876, 872, 3, 2, 2, 2, 876, 874, 3, 2, 2, 2, 877, 878, 3, 2, 2, 2, 878, 901, 7, 615, 2, 2, 879, 885, 7, 218, 2, 2, 880, 882, 7, 201, 2, 2, 881, 883, 7, 218, 2, 2, 882, 881, 3, 2, 2, 2, 882, 883, 3, 2, 2, 2, 883, 885, 3, 2, 2, 2, 884, 879, 3, 2, 2, 2, 884, 880, 3, 2, 2, 2, 885, 886, 3, 2, 2, 2, 886, 901, 5, 528, 265, 2, 887, 888, 7, 212, 2, 2, 888, 889, 7, 181, 2, 2, 889, 901, 7, 615, 2, 2, 890, 892, 7, 212, 2, 2, 891, 893, 9, 2, 2, 2, 892, 891, 3, 2, 2, 2, 892, 893, 3, 2, 2, 2, 893, 894, 3, 2, 2, 2, 894, 896, 7, 433, 2, 2, 895, 897, 7, 218, 2, 2, 896, 895, 3, 2, 2, 2, 896, 897, 3, 2, 2, 2, 897, 898, 3, 2, 2, 2, 898, 901, 5, 528, 265, 2, 899, 901, 5, 24, 13, 2, 900, 849, 3, 2, 2, 2, 900, 861, 3, 2, 2, 2, 900, 876, 3, 2, 2, 2, 900, 884, 3, 2, 2, 2, 900, 887, 3, 2, 2, 2, 900, 890, 3, 2, 2, 2, 900, 899, 3, 2, 2, 2, 901, 21, 3, 2, 2, 2, 902, 903, 7, 123, 2, 2, 903, 911, 7, 130, 2, 2, 904, 912, 7, 227, 2, 2, 905, 906, 7, 203, 2, 2, 906, 912, 7, 192, 2, 2, 907, 908, 7, 192, 2, 2, 908, 912, 7, 39, 2, 2, 909, 910, 7, 192, 2, 2, 910, 912, 7, 268, 2, 2, 911, 904, 3, 2, 2, 2, 911, 905, 3, 2, 2, 2, 911, 907, 3, 2, 2, 2, 911, 909, 3, 2, 2, 2, 912, 922, 3, 2, 2, 2, 913, 914, 7, 192, 2, 2, 914, 922, 7, 290, 2, 2, 915, 916, 7, 192, 2, 2, 916, 922, 7, 420, 2, 2, 917, 919, 7, 416, 2, 2, 918, 917, 3, 2, 2, 2, 918, 919, 3, 2, 2, 2, 919, 920, 3, 2, 2, 2, 920, 922, 7, 392, 2, 2, 921, 902, 3, 2, 2, 2, 921, 913, 3, 2, 2, 2, 921, 915, 3, 2, 2, 2, 921, 918, 3, 2, 2, 2, 922, 23, 3, 2, 2, 2, 923, 925, 7, 135, 2, 2, 924, 926, 7, 431, 2, 2, 925, 924, 3, 2, 2, 2, 925, 926, 3, 2, 2, 2, 926, 927, 3, 2, 2, 2, 927, 932, 5, 390, 196, 2, 928, 929, 7, 581, 2, 2, 929, 931, 5, 390, 196, 2, 930, 928, 3, 2, 2, 2, 931, 934, 3, 2, 2, 2, 932, 930, 3, 2, 2, 2, 932, 933, 3, 2, 2, 2, 933, 939, 3, 2, 2, 2, 934, 932, 3, 2, 2, 2, 935, 936, 7, 407, 2, 2, 936, 937, 5, 26, 14, 2, 937, 938, 7, 145, 2, 2, 938, 940, 3, 2, 2, 2, 939, 935, 3, 2, 2, 2, 939, 940, 3, 2, 2, 2, 940, 942, 3, 2, 2, 2, 941, 943, 7, 155, 2, 2, 942, 941, 3, 2, 2, 2, 942, 943, 3, 2, 2, 2, 943, 25, 3, 2, 2, 2, 944, 945, 9, 4, 2, 2, 945, 957, 7, 232, 2, 2, 946, 947, 7, 324, 2, 2, 947, 957, 7, 83, 2, 2, 948, 949, 7, 232, 2, 2, 949, 950, 9, 5, 2, 2, 950, 957, 7, 83, 2, 2, 951, 957, 7, 232, 2, 2, 952, 954, 7, 5, 2, 2, 953, 952, 3, 2, 2, 2, 953, 954, 3, 2, 2, 2, 954, 955, 3, 2, 2, 2, 955, 957, 7, 83, 2, 2, 956, 944, 3, 2, 2, 2, 956, 946, 3, 2, 2, 2, 956, 948, 3, 2, 2, 2, 956, 951, 3, 2, 2, 2, 956, 953, 3, 2, 2, 2, 957, 27, 3, 2, 2, 2, 958, 986, 5, 30, 16, 2, 959, 960, 7, 275, 2, 2, 960, 962, 5, 50, 26, 2, 961, 963, 5, 46, 24, 2, 962, 961, 3, 2, 2, 2, 962, 963, 3, 2, 2, 2, 963, 986, 3, 2, 2, 2, 964, 966, 9, 6, 2, 2, 965, 967, 5, 58, 30, 2, 966, 965, 3, 2, 2, 2, 966, 967, 3, 2, 2, 2, 967, 969, 3, 2, 2, 2, 968, 970, 9, 7, 2, 2, 969, 968, 3, 2, 2, 2, 969, 970, 3, 2, 2, 2, 970, 971, 3, 2, 2, 2, 971, 986, 5, 528, 265, 2, 972, 975, 7, 33, 2, 2, 973, 976, 5, 528, 265, 2, 974, 976, 7, 368, 2, 2, 975, 973, 3, 2, 2, 2, 975, 974, 3, 2, 2, 2, 976, 986, 3, 2, 2, 2, 977, 978, 7, 24, 2, 2, 978, 986, 5, 582, 292, 2, 979, 980, 7, 69, 2, 2, 980, 986, 9, 8, 2, 2, 981, 986, 5, 38, 20, 2, 982, 986, 5, 36, 19, 2, 983, 986, 5, 32, 17, 2, 984, 986, 5, 40, 21, 2, 985, 958, 3, 2, 2, 2, 985, 959, 3, 2, 2, 2, 985, 964, 3, 2, 2, 2, 985, 972, 3, 2, 2, 2, 985, 977, 3, 2, 2, 2, 985, 979, 3, 2, 2, 2, 985, 981, 3, 2, 2, 2, 985, 982, 3, 2, 2, 2, 985, 983, 3, 2, 2, 2, 985, 984, 3, 2, 2, 2, 986, 29, 3, 2, 2, 2, 987, 1114, 5, 696, 349, 2, 988, 989, 7, 131, 2, 2, 989, 1114, 5, 528, 265, 2, 990, 993, 7, 271, 2, 2, 991, 994, 5, 528, 265, 2, 992, 994, 7, 591, 2, 2, 993, 991, 3, 2, 2, 2, 993, 992, 3, 2, 2, 2, 994, 1114, 3, 2, 2, 2, 995, 1008, 7, 370, 2, 2, 996, 997, 7, 587, 2, 2, 997, 1002, 5, 54, 28, 2, 998, 999, 7, 581, 2, 2, 999, 1001, 5, 54, 28, 2, 1000, 998, 3, 2, 2, 2, 1001, 1004, 3, 2, 2, 2, 1002, 1000, 3, 2, 2, 2, 1002, 1003, 3, 2, 2, 2, 1003, 1005, 3, 2, 2, 2, 1004, 1002, 3, 2, 2, 2, 1005, 1006, 7, 588, 2, 2, 1006, 1009, 3, 2, 2, 2, 1007, 1009, 7, 367, 2, 2, 1008, 996, 3, 2, 2, 2, 1008, 1007, 3, 2, 2, 2, 1008, 1009, 3, 2, 2, 2, 1009, 1011, 3, 2, 2, 2, 1010, 1012, 5, 46, 24, 2, 1011, 1010, 3, 2, 2, 2, 1011, 1012, 3, 2, 2, 2, 1012, 1114, 3, 2, 2, 2, 1013, 1015, 7, 34, 2, 2, 1014, 1016, 7, 367, 2, 2, 1015, 1014, 3, 2, 2, 2, 1015, 1016, 3, 2, 2, 2, 1016, 1026, 3, 2, 2, 2, 1017, 1018, 5, 528, 265, 2, 1018, 1019, 7, 419, 2, 2, 1019, 1020, 5, 618, 310, 2, 1020, 1027, 3, 2, 2, 2, 1021, 1024, 5, 618, 310, 2, 1022, 1023, 7, 439, 2, 2, 1023, 1025, 5, 528, 265, 2, 1024, 1022, 3, 2, 2, 2, 1024, 1025, 3, 2, 2, 2, 1025, 1027, 3, 2, 2, 2, 1026, 1017, 3, 2, 2, 2, 1026, 1021, 3, 2, 2, 2, 1026, 1027, 3, 2, 2, 2, 1027, 1114, 3, 2, 2, 2, 1028, 1114, 7, 31, 2, 2, 1029, 1030, 7, 132, 2, 2, 1030, 1114, 7, 615, 2, 2, 1031, 1033, 7, 57, 2, 2, 1032, 1034, 7, 180, 2, 2, 1033, 1032, 3, 2, 2, 2, 1033, 1034, 3, 2, 2, 2, 1034, 1037, 3, 2, 2, 2, 1035, 1038, 5, 528, 265, 2, 1036, 1038, 7, 368, 2, 2, 1037, 1035, 3, 2, 2, 2, 1037, 1036, 3, 2, 2, 2, 1038, 1114, 3, 2, 2, 2, 1039, 1043, 7, 199, 2, 2, 1040, 1041, 7, 587, 2, 2, 1041, 1042, 7, 367, 2, 2, 1042, 1044, 7, 588, 2, 2, 1043, 1040, 3, 2, 2, 2, 1043, 1044, 3, 2, 2, 2, 1044, 1045, 3, 2, 2, 2, 1045, 1047, 9, 9, 2, 2, 1046, 1048, 7, 348, 2, 2, 1047, 1046, 3, 2, 2, 2, 1047, 1048, 3, 2, 2, 2, 1048, 1049, 3, 2, 2, 2, 1049, 1114, 5, 618, 310, 2, 1050, 1062, 7, 206, 2, 2, 1051, 1052, 5, 528, 265, 2, 1052, 1053, 7, 595, 2, 2, 1053, 1055, 3, 2, 2, 2, 1054, 1051, 3, 2, 2, 2, 1054, 1055, 3, 2, 2, 2, 1055, 1056, 3, 2, 2, 2, 1056, 1063, 5, 528, 265, 2, 1057, 1058, 7, 328, 2, 2, 1058, 1063, 7, 294, 2, 2, 1059, 1060, 7, 229, 2, 2, 1060, 1063, 7, 345, 2, 2, 1061, 1063, 7, 368, 2, 2, 1062, 1054, 3, 2, 2, 2, 1062, 1057, 3, 2, 2, 2, 1062, 1059, 3, 2, 2, 2, 1062, 1061, 3, 2, 2, 2, 1063, 1114, 3, 2, 2, 2, 1064, 1065, 7, 198, 2, 2, 1065, 1066, 7, 140, 2, 2, 1066, 1068, 7, 282, 2, 2, 1067, 1069, 7, 348, 2, 2, 1068, 1067, 3, 2, 2, 2, 1068, 1069, 3, 2, 2, 2, 1069, 1070, 3, 2, 2, 2, 1070, 1076, 5, 618, 310, 2, 1071, 1073, 7, 444, 2, 2, 1072, 1074, 7, 152, 2, 2, 1073, 1072, 3, 2, 2, 2, 1073, 1074, 3, 2, 2, 2, 1074, 1075, 3, 2, 2, 2, 1075, 1077, 7, 54, 2, 2, 1076, 1071, 3, 2, 2, 2, 1076, 1077, 3, 2, 2, 2, 1077, 1114, 3, 2, 2, 2, 1078, 1079, 7, 180, 2, 2, 1079, 1091, 5, 528, 265, 2, 1080, 1081, 7, 587, 2, 2, 1081, 1086, 5, 548, 275, 2, 1082, 1083, 7, 581, 2, 2, 1083, 1085, 5, 548, 275, 2, 1084, 1082, 3, 2, 2, 2, 1085, 1088, 3, 2, 2, 2, 1086, 1084, 3, 2, 2, 2, 1086, 1087, 3, 2, 2, 2, 1087, 1089, 3, 2, 2, 2, 1088, 1086, 3, 2, 2, 2, 1089, 1090, 7, 588, 2, 2, 1090, 1092, 3, 2, 2, 2, 1091, 1080, 3, 2, 2, 2, 1091, 1092, 3, 2, 2, 2, 1092, 1093, 3, 2, 2, 2, 1093, 1094, 7, 374, 2, 2, 1094, 1095, 5, 16, 9, 2, 1095, 1114, 3, 2, 2, 2, 1096, 1097, 7, 193, 2, 2, 1097, 1098, 7, 169, 2, 2, 1098, 1099, 7, 22, 2, 2, 1099, 1104, 5, 44, 23, 2, 1100, 1101, 7, 581, 2, 2, 1101, 1103, 5, 44, 23, 2, 1102, 1100, 3, 2, 2, 2, 1103, 1106, 3, 2, 2, 2, 1104, 1102, 3, 2, 2, 2, 1104, 1105, 3, 2, 2, 2, 1105, 1107, 3, 2, 2, 2, 1106, 1104, 3, 2, 2, 2, 1107, 1108, 7, 433, 2, 2, 1108, 1109, 5, 44, 23, 2, 1109, 1114, 3, 2, 2, 2, 1110, 1114, 5, 396, 199, 2, 1111, 1114, 5, 692, 347, 2, 1112, 1114, 5, 690, 346, 2, 1113, 987, 3, 2, 2, 2, 1113, 988, 3, 2, 2, 2, 1113, 990, 3, 2, 2, 2, 1113, 995, 3, 2, 2, 2, 1113, 1013, 3, 2, 2, 2, 1113, 1028, 3, 2, 2, 2, 1113, 1029, 3, 2, 2, 2, 1113, 1031, 3, 2, 2, 2, 1113, 1039, 3, 2, 2, 2, 1113, 1050, 3, 2, 2, 2, 1113, 1064, 3, 2, 2, 2, 1113, 1078, 3, 2, 2, 2, 1113, 1096, 3, 2, 2, 2, 1113, 1110, 3, 2, 2, 2, 1113, 1111, 3, 2, 2, 2, 1113, 1112, 3, 2, 2, 2, 1114, 31, 3, 2, 2, 2, 1115, 1133, 7, 85, 2, 2, 1116, 1118, 7, 370, 2, 2, 1117, 1116, 3, 2, 2, 2, 1117, 1118, 3, 2, 2, 2, 1118, 1120, 3, 2, 2, 2, 1119, 1121, 7, 367, 2, 2, 1120, 1119, 3, 2, 2, 2, 1120, 1121, 3, 2, 2, 2, 1121, 1134, 3, 2, 2, 2, 1122, 1123, 7, 587, 2, 2, 1123, 1128, 5, 42, 22, 2, 1124, 1125, 7, 581, 2, 2, 1125, 1127, 5, 42, 22, 2, 1126, 1124, 3, 2, 2, 2, 1127, 1130, 3, 2, 2, 2, 1128, 1126, 3, 2, 2, 2, 1128, 1129, 3, 2, 2, 2, 1129, 1131, 3, 2, 2, 2, 1130, 1128, 3, 2, 2, 2, 1131, 1132, 7, 588, 2, 2, 1132, 1134, 3, 2, 2, 2, 1133, 1117, 3, 2, 2, 2, 1133, 1122, 3, 2, 2, 2, 1134, 1135, 3, 2, 2, 2, 1135, 1136, 5, 34, 18, 2, 1136, 33, 3, 2, 2, 2, 1137, 1146, 5, 16, 9, 2, 1138, 1146, 5, 36, 19, 2, 1139, 1146, 5, 38, 20, 2, 1140, 1143, 7, 384, 2, 2, 1141, 1144, 5, 418, 210, 2, 1142, 1144, 5, 406, 204, 2, 1143, 1141, 3, 2, 2, 2, 1143, 1142, 3, 2, 2, 2, 1144, 1146, 3, 2, 2, 2, 1145, 1137, 3, 2, 2, 2, 1145, 1138, 3, 2, 2, 2, 1145, 1139, 3, 2, 2, 2, 1145, 1140, 3, 2, 2, 2, 1146, 35, 3, 2, 2, 2, 1147, 1148, 7, 84, 2, 2, 1148, 1160, 5, 528, 265, 2, 1149, 1150, 7, 587, 2, 2, 1150, 1155, 5, 560, 281, 2, 1151, 1152, 7, 581, 2, 2, 1152, 1154, 5, 560, 281, 2, 1153, 1151, 3, 2, 2, 2, 1154, 1157, 3, 2, 2, 2, 1155, 1153, 3, 2, 2, 2, 1155, 1156, 3, 2, 2, 2, 1156, 1158, 3, 2, 2, 2, 1157, 1155, 3, 2, 2, 2, 1158, 1159, 7, 588, 2, 2, 1159, 1161, 3, 2, 2, 2, 1160, 1149, 3, 2, 2, 2, 1160, 1161, 3, 2, 2, 2, 1161, 37, 3, 2, 2, 2, 1162, 1163, 7, 58, 2, 2, 1163, 1165, 5, 528, 265, 2, 1164, 1166, 7, 346, 2, 2, 1165, 1164, 3, 2, 2, 2, 1165, 1166, 3, 2, 2, 2, 1166, 1168, 3, 2, 2, 2, 1167, 1169, 7, 119, 2, 2, 1168, 1167, 3, 2, 2, 2, 1168, 1169, 3, 2, 2, 2, 1169, 1174, 3, 2, 2, 2, 1170, 1172, 7, 152, 2, 2, 1171, 1170, 3, 2, 2, 2, 1171, 1172, 3, 2, 2, 2, 1172, 1173, 3, 2, 2, 2, 1173, 1175, 7, 221, 2, 2, 1174, 1171, 3, 2, 2, 2, 1174, 1175, 3, 2, 2, 2, 1175, 1176, 3, 2, 2, 2, 1176, 1179, 7, 52, 2, 2, 1177, 1178, 9, 10, 2, 2, 1178, 1180, 7, 102, 2, 2, 1179, 1177, 3, 2, 2, 2, 1179, 1180, 3, 2, 2, 2, 1180, 1181, 3, 2, 2, 2, 1181, 1182, 7, 401, 2, 2, 1182, 1183, 5, 624, 313, 2, 1183, 39, 3, 2, 2, 2, 1184, 1199, 7, 233, 2, 2, 1185, 1186, 5, 528, 265, 2, 1186, 1187, 7, 595, 2, 2, 1187, 1189, 3, 2, 2, 2, 1188, 1185, 3, 2, 2, 2, 1188, 1189, 3, 2, 2, 2, 1189, 1190, 3, 2, 2, 2, 1190, 1200, 5, 528, 265, 2, 1191, 1200, 7, 368, 2, 2, 1192, 1193, 7, 328, 2, 2, 1193, 1200, 7, 294, 2, 2, 1194, 1195, 7, 260, 2, 2, 1195, 1196, 7, 123, 2, 2, 1196, 1200, 7, 130, 2, 2, 1197, 1198, 7, 229, 2, 2, 1198, 1200, 7, 345, 2, 2, 1199, 1188, 3, 2, 2, 2, 1199, 1191, 3, 2, 2, 2, 1199, 1192, 3, 2, 2, 2, 1199, 1194, 3, 2, 2, 2, 1199, 1197, 3, 2, 2, 2, 1200, 41, 3, 2, 2, 2, 1201, 1203, 9, 11, 2, 2, 1202, 1204, 5, 56, 29, 2, 1203, 1202, 3, 2, 2, 2, 1203, 1204, 3, 2, 2, 2, 1204, 1208, 3, 2, 2, 2, 1205, 1206, 7, 469, 2, 2, 1206, 1208, 9, 12, 2, 2, 1207, 1201, 3, 2, 2, 2, 1207, 1205, 3, 2, 2, 2, 1208, 43, 3, 2, 2, 2, 1209, 1213, 5, 528, 265, 2, 1210, 1213, 7, 390, 2, 2, 1211, 1213, 7, 428, 2, 2, 1212, 1209, 3, 2, 2, 2, 1212, 1210, 3, 2, 2, 2, 1212, 1211, 3, 2, 2, 2, 1213, 45, 3, 2, 2, 2, 1214, 1219, 5, 48, 25, 2, 1215, 1216, 7, 581, 2, 2, 1216, 1218, 5, 48, 25, 2, 1217, 1215, 3, 2, 2, 2, 1218, 1221, 3, 2, 2, 2, 1219, 1217, 3, 2, 2, 2, 1219, 1220, 3, 2, 2, 2, 1220, 47, 3, 2, 2, 2, 1221, 1219, 3, 2, 2, 2, 1222, 1234, 5, 618, 310, 2, 1223, 1224, 7, 587, 2, 2, 1224, 1229, 5, 528, 265, 2, 1225, 1226, 7, 581, 2, 2, 1226, 1228, 5, 528, 265, 2, 1227, 1225, 3, 2, 2, 2, 1228, 1231, 3, 2, 2, 2, 1229, 1227, 3, 2, 2, 2, 1229, 1230, 3, 2, 2, 2, 1230, 1232, 3, 2, 2, 2, 1231, 1229, 3, 2, 2, 2, 1232, 1233, 7, 588, 2, 2, 1233, 1235, 3, 2, 2, 2, 1234, 1223, 3, 2, 2, 2, 1234, 1235, 3, 2, 2, 2, 1235, 49, 3, 2, 2, 2, 1236, 1237, 7, 587, 2, 2, 1237, 1242, 5, 52, 27, 2, 1238, 1239, 7, 581, 2, 2, 1239, 1241, 5, 52, 27, 2, 1240, 1238, 3, 2, 2, 2, 1241, 1244, 3, 2, 2, 2, 1242, 1240, 3, 2, 2, 2, 1242, 1243, 3, 2, 2, 2, 1243, 1245, 3, 2, 2, 2, 1244, 1242, 3, 2, 2, 2, 1245, 1246, 7, 588, 2, 2, 1246, 1260, 3, 2, 2, 2, 1247, 1249, 7, 352, 2, 2, 1248, 1247, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249, 1251, 3, 2, 2, 2, 1250, 1252, 7, 351, 2, 2, 1251, 1250, 3, 2, 2, 2, 1251, 1252, 3, 2, 2, 2, 1252, 1254, 3, 2, 2, 2, 1253, 1255, 7, 367, 2, 2, 1254, 1253, 3, 2, 2, 2, 1254, 1255, 3, 2, 2, 2, 1255, 1257, 3, 2, 2, 2, 1256, 1258, 7, 370, 2, 2, 1257, 1256, 3, 2, 2, 2, 1257, 1258, 3, 2, 2, 2, 1258, 1260, 3, 2, 2, 2, 1259, 1236, 3, 2, 2, 2, 1259, 1248, 3, 2, 2, 2, 1260, 51, 3, 2, 2, 2, 1261, 1263, 9, 13, 2, 2, 1262, 1264, 5, 56, 29, 2, 1263, 1262, 3, 2, 2, 2, 1263, 1264, 3, 2, 2, 2, 1264, 53, 3, 2, 2, 2, 1265, 1267, 9, 14, 2, 2, 1266, 1268, 5, 56, 29, 2, 1267, 1266, 3, 2, 2, 2, 1267, 1268, 3, 2, 2, 2, 1268, 55, 3, 2, 2, 2, 1269, 1270, 9, 15, 2, 2, 1270, 57, 3, 2, 2, 2, 1271, 1289, 7, 151, 2, 2, 1272, 1289, 7, 183, 2, 2, 1273, 1289, 7, 90, 2, 2, 1274, 1289, 7, 128, 2, 2, 1275, 1277, 9, 16, 2, 2, 1276, 1275, 3, 2, 2, 2, 1276, 1277, 3, 2, 2, 2, 1277, 1278, 3, 2, 2, 2, 1278, 1289, 5, 336, 169, 2, 1279, 1289, 7, 368, 2, 2, 1280, 1282, 7, 93, 2, 2, 1281, 1283, 9, 17, 2, 2, 1282, 1281, 3, 2, 2, 2, 1282, 1283, 3, 2, 2, 2, 1283, 1289, 3, 2, 2, 2, 1284, 1286, 7, 19, 2, 2, 1285, 1287, 9, 17, 2, 2, 1286, 1285, 3, 2, 2, 2, 1286, 1287, 3, 2, 2, 2, 1287, 1289, 3, 2, 2, 2, 1288, 1271, 3, 2, 2, 2, 1288, 1272, 3, 2, 2, 2, 1288, 1273, 3, 2, 2, 2, 1288, 1274, 3, 2, 2, 2, 1288, 1276, 3, 2, 2, 2, 1288, 1279, 3, 2, 2, 2, 1288, 1280, 3, 2, 2, 2, 1288, 1284, 3, 2, 2, 2, 1289, 59, 3, 2, 2, 2, 1290, 1294, 5, 62, 32, 2, 1291, 1294, 5, 64, 33, 2, 1292, 1294, 5, 66, 34, 2, 1293, 1290, 3, 2, 2, 2, 1293, 1291, 3, 2, 2, 2, 1293, 1292, 3, 2, 2, 2, 1294, 61, 3, 2, 2, 2, 1295, 1334, 7, 384, 2, 2, 1296, 1335, 5, 416, 209, 2, 1297, 1335, 5, 420, 211, 2, 1298, 1335, 5, 144, 73, 2, 1299, 1335, 5, 154, 78, 2, 1300, 1335, 5, 274, 138, 2, 1301, 1335, 5, 270, 136, 2, 1302, 1335, 5, 310, 156, 2, 1303, 1335, 5, 332, 167, 2, 1304, 1335, 5, 342, 172, 2, 1305, 1335, 5, 406, 204, 2, 1306, 1335, 5, 156, 79, 2, 1307, 1335, 5, 158, 80, 2, 1308, 1335, 5, 160, 81, 2, 1309, 1335, 5, 162, 82, 2, 1310, 1335, 5, 164, 83, 2, 1311, 1335, 5, 170, 86, 2, 1312, 1335, 5, 172, 87, 2, 1313, 1335, 5, 174, 88, 2, 1314, 1335, 5, 166, 84, 2, 1315, 1335, 5, 176, 89, 2, 1316, 1335, 5, 182, 92, 2, 1317, 1335, 5, 224, 113, 2, 1318, 1335, 5, 226, 114, 2, 1319, 1335, 5, 228, 115, 2, 1320, 1335, 5, 240, 121, 2, 1321, 1335, 5, 244, 123, 2, 1322, 1335, 5, 246, 124, 2, 1323, 1335, 5, 248, 125, 2, 1324, 1335, 5, 252, 127, 2, 1325, 1335, 5, 258, 130, 2, 1326, 1335, 5, 418, 210, 2, 1327, 1335, 5, 344, 173, 2, 1328, 1335, 5, 350, 176, 2, 1329, 1335, 5, 356, 179, 2, 1330, 1335, 5, 360, 181, 2, 1331, 1335, 5, 372, 187, 2, 1332, 1335, 5, 380, 191, 2, 1333, 1335, 5, 384, 193, 2, 1334, 1296, 3, 2, 2, 2, 1334, 1297, 3, 2, 2, 2, 1334, 1298, 3, 2, 2, 2, 1334, 1299, 3, 2, 2, 2, 1334, 1300, 3, 2, 2, 2, 1334, 1301, 3, 2, 2, 2, 1334, 1302, 3, 2, 2, 2, 1334, 1303, 3, 2, 2, 2, 1334, 1304, 3, 2, 2, 2, 1334, 1305, 3, 2, 2, 2, 1334, 1306, 3, 2, 2, 2, 1334, 1307, 3, 2, 2, 2, 1334, 1308, 3, 2, 2, 2, 1334, 1309, 3, 2, 2, 2, 1334, 1310, 3, 2, 2, 2, 1334, 1311, 3, 2, 2, 2, 1334, 1312, 3, 2, 2, 2, 1334, 1313, 3, 2, 2, 2, 1334, 1314, 3, 2, 2, 2, 1334, 1315, 3, 2, 2, 2, 1334, 1316, 3, 2, 2, 2, 1334, 1317, 3, 2, 2, 2, 1334, 1318, 3, 2, 2, 2, 1334, 1319, 3, 2, 2, 2, 1334, 1320, 3, 2, 2, 2, 1334, 1321, 3, 2, 2, 2, 1334, 1322, 3, 2, 2, 2, 1334, 1323, 3, 2, 2, 2, 1334, 1324, 3, 2, 2, 2, 1334, 1325, 3, 2, 2, 2, 1334, 1326, 3, 2, 2, 2, 1334, 1327, 3, 2, 2, 2, 1334, 1328, 3, 2, 2, 2, 1334, 1329, 3, 2, 2, 2, 1334, 1330, 3, 2, 2, 2, 1334, 1331, 3, 2, 2, 2, 1334, 1332, 3, 2, 2, 2, 1334, 1333, 3, 2, 2, 2, 1335, 1342, 3, 2, 2, 2, 1336, 1342, 5, 302, 152, 2, 1337, 1342, 5, 280, 141, 2, 1338, 1342, 5, 262, 132, 2, 1339, 1342, 5, 68, 35, 2, 1340, 1342, 5, 304, 153, 2, 1341, 1295, 3, 2, 2, 2, 1341, 1336, 3, 2, 2, 2, 1341, 1337, 3, 2, 2, 2, 1341, 1338, 3, 2, 2, 2, 1341, 1339, 3, 2, 2, 2, 1341, 1340, 3, 2, 2, 2, 1342, 63, 3, 2, 2, 2, 1343, 1376, 7, 12, 2, 2, 1344, 1377, 5, 70, 36, 2, 1345, 1377, 5, 80, 41, 2, 1346, 1377, 5, 82, 42, 2, 1347, 1377, 5, 84, 43, 2, 1348, 1377, 5, 108, 55, 2, 1349, 1377, 5, 112, 57, 2, 1350, 1377, 5, 118, 60, 2, 1351, 1377, 5, 120, 61, 2, 1352, 1377, 5, 122, 62, 2, 1353, 1377, 5, 126, 64, 2, 1354, 1377, 5, 128, 65, 2, 1355, 1377, 5, 130, 66, 2, 1356, 1377, 5, 134, 68, 2, 1357, 1377, 5, 178, 90, 2, 1358, 1377, 5, 184, 93, 2, 1359, 1377, 5, 186, 94, 2, 1360, 1377, 5, 192, 97, 2, 1361, 1377, 5, 196, 99, 2, 1362, 1377, 5, 202, 102, 2, 1363, 1377, 5, 204, 103, 2, 1364, 1377, 5, 208, 105, 2, 1365, 1377, 5, 72, 37, 2, 1366, 1377, 5, 74, 38, 2, 1367, 1377, 5, 346, 174, 2, 1368, 1377, 5, 352, 177, 2, 1369, 1377, 5, 392, 197, 2, 1370, 1377, 5, 394, 198, 2, 1371, 1377, 5, 362, 182, 2, 1372, 1377, 5, 376, 189, 2, 1373, 1377, 5, 382, 192, 2, 1374, 1377, 5, 386, 194, 2, 1375, 1377, 5, 198, 100, 2, 1376, 1344, 3, 2, 2, 2, 1376, 1345, 3, 2, 2, 2, 1376, 1346, 3, 2, 2, 2, 1376, 1347, 3, 2, 2, 2, 1376, 1348, 3, 2, 2, 2, 1376, 1349, 3, 2, 2, 2, 1376, 1350, 3, 2, 2, 2, 1376, 1351, 3, 2, 2, 2, 1376, 1352, 3, 2, 2, 2, 1376, 1353, 3, 2, 2, 2, 1376, 1354, 3, 2, 2, 2, 1376, 1355, 3, 2, 2, 2, 1376, 1356, 3, 2, 2, 2, 1376, 1357, 3, 2, 2, 2, 1376, 1358, 3, 2, 2, 2, 1376, 1359, 3, 2, 2, 2, 1376, 1360, 3, 2, 2, 2, 1376, 1361, 3, 2, 2, 2, 1376, 1362, 3, 2, 2, 2, 1376, 1363, 3, 2, 2, 2, 1376, 1364, 3, 2, 2, 2, 1376, 1365, 3, 2, 2, 2, 1376, 1366, 3, 2, 2, 2, 1376, 1367, 3, 2, 2, 2, 1376, 1368, 3, 2, 2, 2, 1376, 1369, 3, 2, 2, 2, 1376, 1370, 3, 2, 2, 2, 1376, 1371, 3, 2, 2, 2, 1376, 1372, 3, 2, 2, 2, 1376, 1373, 3, 2, 2, 2, 1376, 1374, 3, 2, 2, 2, 1376, 1375, 3, 2, 2, 2, 1377, 65, 3, 2, 2, 2, 1378, 1390, 7, 73, 2, 2, 1379, 1391, 5, 516, 259, 2, 1380, 1391, 5, 518, 260, 2, 1381, 1391, 5, 520, 261, 2, 1382, 1391, 5, 348, 175, 2, 1383, 1391, 5, 358, 180, 2, 1384, 1391, 5, 370, 186, 2, 1385, 1391, 5, 378, 190, 2, 1386, 1391, 5, 522, 262, 2, 1387, 1391, 5, 214, 108, 2, 1388, 1391, 5, 216, 109, 2, 1389, 1391, 5, 218, 110, 2, 1390, 1379, 3, 2, 2, 2, 1390, 1380, 3, 2, 2, 2, 1390, 1381, 3, 2, 2, 2, 1390, 1382, 3, 2, 2, 2, 1390, 1383, 3, 2, 2, 2, 1390, 1384, 3, 2, 2, 2, 1390, 1385, 3, 2, 2, 2, 1390, 1386, 3, 2, 2, 2, 1390, 1387, 3, 2, 2, 2, 1390, 1388, 3, 2, 2, 2, 1390, 1389, 3, 2, 2, 2, 1391, 67, 3, 2, 2, 2, 1392, 1393, 7, 109, 2, 2, 1393, 1394, 7, 402, 2, 2, 1394, 1395, 7, 219, 2, 2, 1395, 1405, 5, 528, 265, 2, 1396, 1397, 7, 413, 2, 2, 1397, 1400, 7, 433, 2, 2, 1398, 1400, 7, 398, 2, 2, 1399, 1396, 3, 2, 2, 2, 1399, 1398, 3, 2, 2, 2, 1400, 1401, 3, 2, 2, 2, 1401, 1402, 7, 587, 2, 2, 1402, 1403, 5, 694, 348, 2, 1403, 1404, 7, 588, 2, 2, 1404, 1406, 3, 2, 2, 2, 1405, 1399, 3, 2, 2, 2, 1405, 1406, 3, 2, 2, 2, 1406, 1407, 3, 2, 2, 2, 1407, 1408, 7, 403, 2, 2, 1408, 1409, 7, 228, 2, 2, 1409, 1410, 5, 528, 265, 2, 1410, 1411, 7, 410, 2, 2, 1411, 1413, 5, 528, 265, 2, 1412, 1414, 5, 444, 223, 2, 1413, 1412, 3, 2, 2, 2, 1413, 1414, 3, 2, 2, 2, 1414, 69, 3, 2, 2, 2, 1415, 1417, 9, 18, 2, 2, 1416, 1418, 5, 320, 161, 2, 1417, 1416, 3, 2, 2, 2, 1417, 1418, 3, 2, 2, 2, 1418, 1443, 3, 2, 2, 2, 1419, 1431, 5, 104, 53, 2, 1420, 1428, 7, 206, 2, 2, 1421, 1422, 5, 528, 265, 2, 1422, 1423, 7, 595, 2, 2, 1423, 1425, 3, 2, 2, 2, 1424, 1421, 3, 2, 2, 2, 1424, 1425, 3, 2, 2, 2, 1425, 1426, 3, 2, 2, 2, 1426, 1429, 5, 528, 265, 2, 1427, 1429, 7, 368, 2, 2, 1428, 1424, 3, 2, 2, 2, 1428, 1427, 3, 2, 2, 2, 1429, 1431, 3, 2, 2, 2, 1430, 1419, 3, 2, 2, 2, 1430, 1420, 3, 2, 2, 2, 1431, 1432, 3, 2, 2, 2, 1432, 1430, 3, 2, 2, 2, 1432, 1433, 3, 2, 2, 2, 1433, 1435, 3, 2, 2, 2, 1434, 1436, 7, 208, 2, 2, 1435, 1434, 3, 2, 2, 2, 1435, 1436, 3, 2, 2, 2, 1436, 1444, 3, 2, 2, 2, 1437, 1444, 5, 494, 248, 2, 1438, 1444, 5, 496, 249, 2, 1439, 1440, 7, 65, 2, 2, 1440, 1441, 7, 419, 2, 2, 1441, 1442, 7, 86, 2, 2, 1442, 1444, 5, 528, 265, 2, 1443, 1430, 3, 2, 2, 2, 1443, 1437, 3, 2, 2, 2, 1443, 1438, 3, 2, 2, 2, 1443, 1439, 3, 2, 2, 2, 1444, 71, 3, 2, 2, 2, 1445, 1446, 7, 10, 2, 2, 1446, 1449, 5, 320, 161, 2, 1447, 1450, 5, 494, 248, 2, 1448, 1450, 5, 496, 249, 2, 1449, 1447, 3, 2, 2, 2, 1449, 1448, 3, 2, 2, 2, 1450, 73, 3, 2, 2, 2, 1451, 1452, 7, 86, 2, 2, 1452, 1453, 5, 528, 265, 2, 1453, 1454, 5, 76, 39, 2, 1454, 75, 3, 2, 2, 2, 1455, 1467, 5, 496, 249, 2, 1456, 1462, 7, 274, 2, 2, 1457, 1460, 7, 433, 2, 2, 1458, 1461, 5, 528, 265, 2, 1459, 1461, 5, 326, 164, 2, 1460, 1458, 3, 2, 2, 2, 1460, 1459, 3, 2, 2, 2, 1461, 1463, 3, 2, 2, 2, 1462, 1457, 3, 2, 2, 2, 1462, 1463, 3, 2, 2, 2, 1463, 1467, 3, 2, 2, 2, 1464, 1465, 9, 19, 2, 2, 1465, 1467, 5, 78, 40, 2, 1466, 1455, 3, 2, 2, 2, 1466, 1456, 3, 2, 2, 2, 1466, 1464, 3, 2, 2, 2, 1467, 77, 3, 2, 2, 2, 1468, 1469, 7, 5, 2, 2, 1469, 1470, 7, 142, 2, 2, 1470, 1559, 5, 618, 310, 2, 1471, 1472, 7, 10, 2, 2, 1472, 1559, 5, 320, 161, 2, 1473, 1474, 7, 379, 2, 2, 1474, 1475, 7, 587, 2, 2, 1475, 1476, 5, 618, 310, 2, 1476, 1477, 7, 374, 2, 2, 1477, 1478, 5, 618, 310, 2, 1478, 1479, 7, 588, 2, 2, 1479, 1559, 3, 2, 2, 2, 1480, 1481, 7, 347, 2, 2, 1481, 1559, 5, 528, 265, 2, 1482, 1483, 7, 46, 2, 2, 1483, 1559, 5, 528, 265, 2, 1484, 1485, 7, 71, 2, 2, 1485, 1559, 5, 618, 310, 2, 1486, 1487, 7, 80, 2, 2, 1487, 1488, 7, 262, 2, 2, 1488, 1559, 5, 528, 265, 2, 1489, 1490, 7, 402, 2, 2, 1490, 1491, 7, 54, 2, 2, 1491, 1492, 7, 289, 2, 2, 1492, 1559, 5, 528, 265, 2, 1493, 1494, 7, 402, 2, 2, 1494, 1495, 7, 431, 2, 2, 1495, 1559, 5, 618, 310, 2, 1496, 1497, 7, 94, 2, 2, 1497, 1559, 5, 320, 161, 2, 1498, 1500, 7, 140, 2, 2, 1499, 1498, 3, 2, 2, 2, 1499, 1500, 3, 2, 2, 2, 1500, 1501, 3, 2, 2, 2, 1501, 1502, 7, 282, 2, 2, 1502, 1559, 5, 618, 310, 2, 1503, 1504, 7, 162, 2, 2, 1504, 1559, 5, 254, 128, 2, 1505, 1506, 7, 162, 2, 2, 1506, 1507, 7, 32, 2, 2, 1507, 1508, 5, 618, 310, 2, 1508, 1509, 7, 439, 2, 2, 1509, 1510, 5, 528, 265, 2, 1510, 1559, 3, 2, 2, 2, 1511, 1512, 7, 162, 2, 2, 1512, 1513, 7, 88, 2, 2, 1513, 1514, 5, 618, 310, 2, 1514, 1515, 7, 439, 2, 2, 1515, 1516, 5, 528, 265, 2, 1516, 1559, 3, 2, 2, 2, 1517, 1519, 7, 185, 2, 2, 1518, 1517, 3, 2, 2, 2, 1518, 1519, 3, 2, 2, 2, 1519, 1520, 3, 2, 2, 2, 1520, 1521, 7, 126, 2, 2, 1521, 1559, 5, 528, 265, 2, 1522, 1523, 7, 186, 2, 2, 1523, 1559, 5, 320, 161, 2, 1524, 1525, 7, 214, 2, 2, 1525, 1559, 5, 320, 161, 2, 1526, 1527, 7, 219, 2, 2, 1527, 1559, 5, 528, 265, 2, 1528, 1529, 7, 225, 2, 2, 1529, 1559, 5, 618, 310, 2, 1530, 1531, 7, 228, 2, 2, 1531, 1559, 5, 528, 265, 2, 1532, 1533, 7, 431, 2, 2, 1533, 1559, 5, 618, 310, 2, 1534, 1535, 7, 258, 2, 2, 1535, 1536, 7, 222, 2, 2, 1536, 1537, 7, 40, 2, 2, 1537, 1559, 5, 618, 310, 2, 1538, 1539, 7, 258, 2, 2, 1539, 1540, 7, 222, 2, 2, 1540, 1541, 7, 67, 2, 2, 1541, 1559, 5, 618, 310, 2, 1542, 1543, 7, 258, 2, 2, 1543, 1544, 7, 222, 2, 2, 1544, 1545, 7, 172, 2, 2, 1545, 1559, 5, 618, 310, 2, 1546, 1547, 7, 258, 2, 2, 1547, 1548, 7, 222, 2, 2, 1548, 1549, 7, 256, 2, 2, 1549, 1559, 5, 618, 310, 2, 1550, 1551, 7, 261, 2, 2, 1551, 1552, 7, 401, 2, 2, 1552, 1553, 5, 528, 265, 2, 1553, 1554, 7, 126, 2, 2, 1554, 1555, 5, 528, 265, 2, 1555, 1559, 3, 2, 2, 2, 1556, 1557, 7, 265, 2, 2, 1557, 1559, 5, 618, 310, 2, 1558, 1468, 3, 2, 2, 2, 1558, 1471, 3, 2, 2, 2, 1558, 1473, 3, 2, 2, 2, 1558, 1480, 3, 2, 2, 2, 1558, 1482, 3, 2, 2, 2, 1558, 1484, 3, 2, 2, 2, 1558, 1486, 3, 2, 2, 2, 1558, 1489, 3, 2, 2, 2, 1558, 1493, 3, 2, 2, 2, 1558, 1496, 3, 2, 2, 2, 1558, 1499, 3, 2, 2, 2, 1558, 1503, 3, 2, 2, 2, 1558, 1505, 3, 2, 2, 2, 1558, 1511, 3, 2, 2, 2, 1558, 1518, 3, 2, 2, 2, 1558, 1522, 3, 2, 2, 2, 1558, 1524, 3, 2, 2, 2, 1558, 1526, 3, 2, 2, 2, 1558, 1528, 3, 2, 2, 2, 1558, 1530, 3, 2, 2, 2, 1558, 1532, 3, 2, 2, 2, 1558, 1534, 3, 2, 2, 2, 1558, 1538, 3, 2, 2, 2, 1558, 1542, 3, 2, 2, 2, 1558, 1546, 3, 2, 2, 2, 1558, 1550, 3, 2, 2, 2, 1558, 1556, 3, 2, 2, 2, 1559, 79, 3, 2, 2, 2, 1560, 1561, 7, 219, 2, 2, 1561, 1562, 5, 528, 265, 2, 1562, 1563, 5, 494, 248, 2, 1563, 81, 3, 2, 2, 2, 1564, 1566, 7, 185, 2, 2, 1565, 1564, 3, 2, 2, 2, 1565, 1566, 3, 2, 2, 2, 1566, 1567, 3, 2, 2, 2, 1567, 1568, 7, 126, 2, 2, 1568, 1571, 5, 528, 265, 2, 1569, 1572, 5, 494, 248, 2, 1570, 1572, 5, 492, 247, 2, 1571, 1569, 3, 2, 2, 2, 1571, 1570, 3, 2, 2, 2, 1572, 83, 3, 2, 2, 2, 1573, 1575, 7, 402, 2, 2, 1574, 1573, 3, 2, 2, 2, 1574, 1575, 3, 2, 2, 2, 1575, 1576, 3, 2, 2, 2, 1576, 1578, 7, 431, 2, 2, 1577, 1579, 5, 408, 205, 2, 1578, 1577, 3, 2, 2, 2, 1578, 1579, 3, 2, 2, 2, 1579, 1581, 3, 2, 2, 2, 1580, 1582, 7, 420, 2, 2, 1581, 1580, 3, 2, 2, 2, 1581, 1582, 3, 2, 2, 2, 1582, 1583, 3, 2, 2, 2, 1583, 1585, 5, 618, 310, 2, 1584, 1586, 7, 591, 2, 2, 1585, 1584, 3, 2, 2, 2, 1585, 1586, 3, 2, 2, 2, 1586, 1619, 3, 2, 2, 2, 1587, 1592, 5, 86, 44, 2, 1588, 1589, 7, 581, 2, 2, 1589, 1591, 5, 86, 44, 2, 1590, 1588, 3, 2, 2, 2, 1591, 1594, 3, 2, 2, 2, 1592, 1590, 3, 2, 2, 2, 1592, 1593, 3, 2, 2, 2, 1593, 1620, 3, 2, 2, 2, 1594, 1592, 3, 2, 2, 2, 1595, 1597, 7, 202, 2, 2, 1596, 1598, 7, 382, 2, 2, 1597, 1596, 3, 2, 2, 2, 1597, 1598, 3, 2, 2, 2, 1598, 1599, 3, 2, 2, 2, 1599, 1600, 5, 528, 265, 2, 1600, 1601, 7, 433, 2, 2, 1601, 1602, 5, 528, 265, 2, 1602, 1620, 3, 2, 2, 2, 1603, 1620, 5, 496, 249, 2, 1604, 1620, 5, 494, 248, 2, 1605, 1606, 7, 202, 2, 2, 1606, 1607, 7, 383, 2, 2, 1607, 1608, 5, 528, 265, 2, 1608, 1609, 7, 433, 2, 2, 1609, 1610, 5, 528, 265, 2, 1610, 1620, 3, 2, 2, 2, 1611, 1612, 7, 17, 2, 2, 1612, 1613, 7, 174, 2, 2, 1613, 1614, 5, 618, 310, 2, 1614, 1615, 5, 426, 214, 2, 1615, 1620, 3, 2, 2, 2, 1616, 1617, 7, 66, 2, 2, 1617, 1618, 7, 174, 2, 2, 1618, 1620, 5, 618, 310, 2, 1619, 1587, 3, 2, 2, 2, 1619, 1595, 3, 2, 2, 2, 1619, 1603, 3, 2, 2, 2, 1619, 1604, 3, 2, 2, 2, 1619, 1605, 3, 2, 2, 2, 1619, 1611, 3, 2, 2, 2, 1619, 1616, 3, 2, 2, 2, 1620, 85, 3, 2, 2, 2, 1621, 1623, 7, 7, 2, 2, 1622, 1624, 7, 382, 2, 2, 1623, 1622, 3, 2, 2, 2, 1623, 1624, 3, 2, 2, 2, 1624, 1626, 3, 2, 2, 2, 1625, 1627, 5, 410, 206, 2, 1626, 1625, 3, 2, 2, 2, 1626, 1627, 3, 2, 2, 2, 1627, 1628, 3, 2, 2, 2, 1628, 1732, 5, 456, 229, 2, 1629, 1631, 7, 73, 2, 2, 1630, 1632, 7, 382, 2, 2, 1631, 1630, 3, 2, 2, 2, 1631, 1632, 3, 2, 2, 2, 1632, 1634, 3, 2, 2, 2, 1633, 1635, 5, 408, 205, 2, 1634, 1633, 3, 2, 2, 2, 1634, 1635, 3, 2, 2, 2, 1635, 1636, 3, 2, 2, 2, 1636, 1638, 5, 528, 265, 2, 1637, 1639, 5, 504, 253, 2, 1638, 1637, 3, 2, 2, 2, 1638, 1639, 3, 2, 2, 2, 1639, 1732, 3, 2, 2, 2, 1640, 1642, 7, 12, 2, 2, 1641, 1643, 7, 382, 2, 2, 1642, 1641, 3, 2, 2, 2, 1642, 1643, 3, 2, 2, 2, 1643, 1644, 3, 2, 2, 2, 1644, 1645, 5, 528, 265, 2, 1645, 1646, 5, 88, 45, 2, 1646, 1732, 3, 2, 2, 2, 1647, 1648, 7, 7, 2, 2, 1648, 1651, 5, 460, 231, 2, 1649, 1650, 7, 416, 2, 2, 1650, 1652, 7, 276, 2, 2, 1651, 1649, 3, 2, 2, 2, 1651, 1652, 3, 2, 2, 2, 1652, 1732, 3, 2, 2, 2, 1653, 1732, 5, 96, 49, 2, 1654, 1732, 5, 98, 50, 2, 1655, 1656, 9, 20, 2, 2, 1656, 1660, 7, 262, 2, 2, 1657, 1661, 5, 618, 310, 2, 1658, 1661, 7, 368, 2, 2, 1659, 1661, 7, 438, 2, 2, 1660, 1657, 3, 2, 2, 2, 1660, 1658, 3, 2, 2, 2, 1660, 1659, 3, 2, 2, 2, 1660, 1661, 3, 2, 2, 2, 1661, 1732, 3, 2, 2, 2, 1662, 1663, 7, 75, 2, 2, 1663, 1664, 9, 21, 2, 2, 1664, 1665, 7, 262, 2, 2, 1665, 1732, 5, 618, 310, 2, 1666, 1667, 9, 20, 2, 2, 1667, 1668, 7, 217, 2, 2, 1668, 1732, 5, 618, 310, 2, 1669, 1670, 7, 75, 2, 2, 1670, 1671, 9, 21, 2, 2, 1671, 1672, 7, 217, 2, 2, 1672, 1732, 5, 618, 310, 2, 1673, 1674, 9, 20, 2, 2, 1674, 1675, 7, 324, 2, 2, 1675, 1676, 7, 130, 2, 2, 1676, 1732, 7, 224, 2, 2, 1677, 1679, 7, 152, 2, 2, 1678, 1677, 3, 2, 2, 2, 1678, 1679, 3, 2, 2, 2, 1679, 1680, 3, 2, 2, 2, 1680, 1681, 7, 92, 2, 2, 1681, 1682, 7, 324, 2, 2, 1682, 1683, 7, 130, 2, 2, 1683, 1732, 7, 224, 2, 2, 1684, 1685, 7, 34, 2, 2, 1685, 1686, 7, 419, 2, 2, 1686, 1732, 5, 618, 310, 2, 1687, 1688, 7, 230, 2, 2, 1688, 1689, 7, 287, 2, 2, 1689, 1732, 9, 22, 2, 2, 1690, 1691, 7, 230, 2, 2, 1691, 1692, 7, 444, 2, 2, 1692, 1732, 7, 160, 2, 2, 1693, 1694, 7, 230, 2, 2, 1694, 1732, 9, 23, 2, 2, 1695, 1696, 7, 230, 2, 2, 1696, 1732, 5, 476, 239, 2, 1697, 1698, 7, 206, 2, 2, 1698, 1732, 5, 472, 237, 2, 1699, 1732, 5, 444, 223, 2, 1700, 1701, 7, 115, 2, 2, 1701, 1732, 5, 618, 310, 2, 1702, 1703, 7, 152, 2, 2, 1703, 1704, 7, 115, 2, 2, 1704, 1732, 5, 618, 310, 2, 1705, 1706, 7, 158, 2, 2, 1706, 1732, 5, 618, 310, 2, 1707, 1708, 7, 416, 2, 2, 1708, 1732, 7, 158, 2, 2, 1709, 1732, 5, 492, 247, 2, 1710, 1711, 7, 230, 2, 2, 1711, 1732, 5, 488, 245, 2, 1712, 1713, 7, 205, 2, 2, 1713, 1720, 7, 104, 2, 2, 1714, 1721, 7, 391, 2, 2, 1715, 1721, 7, 352, 2, 2, 1716, 1721, 7, 153, 2, 2, 1717, 1718, 7, 439, 2, 2, 1718, 1719, 7, 113, 2, 2, 1719, 1721, 5, 528, 265, 2, 1720, 1714, 3, 2, 2, 2, 1720, 1715, 3, 2, 2, 2, 1720, 1716, 3, 2, 2, 2, 1720, 1717, 3, 2, 2, 2, 1721, 1732, 3, 2, 2, 2, 1722, 1723, 7, 12, 2, 2, 1723, 1724, 7, 383, 2, 2, 1724, 1726, 5, 528, 265, 2, 1725, 1727, 5, 100, 51, 2, 1726, 1725, 3, 2, 2, 2, 1726, 1727, 3, 2, 2, 2, 1727, 1729, 3, 2, 2, 2, 1728, 1730, 5, 102, 52, 2, 1729, 1728, 3, 2, 2, 2, 1729, 1730, 3, 2, 2, 2, 1730, 1732, 3, 2, 2, 2, 1731, 1621, 3, 2, 2, 2, 1731, 1629, 3, 2, 2, 2, 1731, 1640, 3, 2, 2, 2, 1731, 1647, 3, 2, 2, 2, 1731, 1653, 3, 2, 2, 2, 1731, 1654, 3, 2, 2, 2, 1731, 1655, 3, 2, 2, 2, 1731, 1662, 3, 2, 2, 2, 1731, 1666, 3, 2, 2, 2, 1731, 1669, 3, 2, 2, 2, 1731, 1673, 3, 2, 2, 2, 1731, 1678, 3, 2, 2, 2, 1731, 1684, 3, 2, 2, 2, 1731, 1687, 3, 2, 2, 2, 1731, 1690, 3, 2, 2, 2, 1731, 1693, 3, 2, 2, 2, 1731, 1695, 3, 2, 2, 2, 1731, 1697, 3, 2, 2, 2, 1731, 1699, 3, 2, 2, 2, 1731, 1700, 3, 2, 2, 2, 1731, 1702, 3, 2, 2, 2, 1731, 1705, 3, 2, 2, 2, 1731, 1707, 3, 2, 2, 2, 1731, 1709, 3, 2, 2, 2, 1731, 1710, 3, 2, 2, 2, 1731, 1712, 3, 2, 2, 2, 1731, 1722, 3, 2, 2, 2, 1732, 87, 3, 2, 2, 2, 1733, 1734, 7, 230, 2, 2, 1734, 1736, 7, 54, 2, 2, 1735, 1733, 3, 2, 2, 2, 1735, 1736, 3, 2, 2, 2, 1736, 1737, 3, 2, 2, 2, 1737, 1738, 7, 265, 2, 2, 1738, 1740, 5, 548, 275, 2, 1739, 1741, 5, 506, 254, 2, 1740, 1739, 3, 2, 2, 2, 1740, 1741, 3, 2, 2, 2, 1741, 1744, 3, 2, 2, 2, 1742, 1743, 7, 439, 2, 2, 1743, 1745, 5, 560, 281, 2, 1744, 1742, 3, 2, 2, 2, 1744, 1745, 3, 2, 2, 2, 1745, 1778, 3, 2, 2, 2, 1746, 1747, 7, 7, 2, 2, 1747, 1778, 5, 90, 46, 2, 1748, 1778, 5, 140, 71, 2, 1749, 1778, 5, 142, 72, 2, 1750, 1753, 7, 230, 2, 2, 1751, 1753, 7, 73, 2, 2, 1752, 1750, 3, 2, 2, 2, 1752, 1751, 3, 2, 2, 2, 1753, 1754, 3, 2, 2, 2, 1754, 1755, 7, 416, 2, 2, 1755, 1778, 7, 417, 2, 2, 1756, 1757, 7, 73, 2, 2, 1757, 1759, 7, 104, 2, 2, 1758, 1760, 5, 408, 205, 2, 1759, 1758, 3, 2, 2, 2, 1759, 1760, 3, 2, 2, 2, 1760, 1778, 3, 2, 2, 2, 1761, 1762, 7, 230, 2, 2, 1762, 1778, 5, 476, 239, 2, 1763, 1764, 7, 230, 2, 2, 1764, 1765, 7, 242, 2, 2, 1765, 1778, 5, 336, 169, 2, 1766, 1767, 7, 230, 2, 2, 1767, 1768, 7, 245, 2, 2, 1768, 1778, 5, 94, 48, 2, 1769, 1770, 7, 206, 2, 2, 1770, 1778, 5, 472, 237, 2, 1771, 1778, 5, 444, 223, 2, 1772, 1774, 5, 92, 47, 2, 1773, 1772, 3, 2, 2, 2, 1774, 1775, 3, 2, 2, 2, 1775, 1773, 3, 2, 2, 2, 1775, 1776, 3, 2, 2, 2, 1776, 1778, 3, 2, 2, 2, 1777, 1735, 3, 2, 2, 2, 1777, 1746, 3, 2, 2, 2, 1777, 1748, 3, 2, 2, 2, 1777, 1749, 3, 2, 2, 2, 1777, 1752, 3, 2, 2, 2, 1777, 1756, 3, 2, 2, 2, 1777, 1761, 3, 2, 2, 2, 1777, 1763, 3, 2, 2, 2, 1777, 1766, 3, 2, 2, 2, 1777, 1769, 3, 2, 2, 2, 1777, 1771, 3, 2, 2, 2, 1777, 1773, 3, 2, 2, 2, 1778, 89, 3, 2, 2, 2, 1779, 1783, 7, 96, 2, 2, 1780, 1784, 7, 13, 2, 2, 1781, 1782, 7, 22, 2, 2, 1782, 1784, 7, 391, 2, 2, 1783, 1780, 3, 2, 2, 2, 1783, 1781, 3, 2, 2, 2, 1784, 1785, 3, 2, 2, 2, 1785, 1786, 7, 374, 2, 2, 1786, 1795, 7, 104, 2, 2, 1787, 1789, 7, 587, 2, 2, 1788, 1790, 5, 334, 168, 2, 1789, 1788, 3, 2, 2, 2, 1790, 1791, 3, 2, 2, 2, 1791, 1789, 3, 2, 2, 2, 1791, 1792, 3, 2, 2, 2, 1792, 1793, 3, 2, 2, 2, 1793, 1794, 7, 588, 2, 2, 1794, 1796, 3, 2, 2, 2, 1795, 1787, 3, 2, 2, 2, 1795, 1796, 3, 2, 2, 2, 1796, 91, 3, 2, 2, 2, 1797, 1798, 7, 230, 2, 2, 1798, 1802, 7, 96, 2, 2, 1799, 1803, 7, 13, 2, 2, 1800, 1801, 7, 22, 2, 2, 1801, 1803, 7, 391, 2, 2, 1802, 1799, 3, 2, 2, 2, 1802, 1800, 3, 2, 2, 2, 1803, 1814, 3, 2, 2, 2, 1804, 1805, 7, 230, 2, 2, 1805, 1814, 5, 334, 168, 2, 1806, 1811, 7, 207, 2, 2, 1807, 1809, 7, 444, 2, 2, 1808, 1807, 3, 2, 2, 2, 1808, 1809, 3, 2, 2, 2, 1809, 1810, 3, 2, 2, 2, 1810, 1812, 7, 610, 2, 2, 1811, 1808, 3, 2, 2, 2, 1811, 1812, 3, 2, 2, 2, 1812, 1814, 3, 2, 2, 2, 1813, 1797, 3, 2, 2, 2, 1813, 1804, 3, 2, 2, 2, 1813, 1806, 3, 2, 2, 2, 1814, 93, 3, 2, 2, 2, 1815, 1816, 9, 24, 2, 2, 1816, 95, 3, 2, 2, 2, 1817, 1818, 7, 277, 2, 2, 1818, 1819, 7, 383, 2, 2, 1819, 1820, 5, 618, 310, 2, 1820, 97, 3, 2, 2, 2, 1821, 1822, 7, 73, 2, 2, 1822, 1824, 7, 383, 2, 2, 1823, 1825, 5, 408, 205, 2, 1824, 1823, 3, 2, 2, 2, 1824, 1825, 3, 2, 2, 2, 1825, 1826, 3, 2, 2, 2, 1826, 1828, 5, 528, 265, 2, 1827, 1829, 5, 504, 253, 2, 1828, 1827, 3, 2, 2, 2, 1828, 1829, 3, 2, 2, 2, 1829, 99, 3, 2, 2, 2, 1830, 1832, 7, 416, 2, 2, 1831, 1830, 3, 2, 2, 2, 1831, 1832, 3, 2, 2, 2, 1832, 1833, 3, 2, 2, 2, 1833, 1834, 7, 392, 2, 2, 1834, 101, 3, 2, 2, 2, 1835, 1836, 7, 408, 2, 2, 1836, 1837, 9, 25, 2, 2, 1837, 103, 3, 2, 2, 2, 1838, 1842, 7, 25, 2, 2, 1839, 1840, 7, 209, 2, 2, 1840, 1842, 7, 417, 2, 2, 1841, 1838, 3, 2, 2, 2, 1841, 1839, 3, 2, 2, 2, 1842, 1843, 3, 2, 2, 2, 1843, 1844, 7, 419, 2, 2, 1844, 1845, 7, 417, 2, 2, 1845, 1895, 7, 118, 2, 2, 1846, 1847, 7, 261, 2, 2, 1847, 1852, 5, 314, 158, 2, 1848, 1849, 7, 581, 2, 2, 1849, 1851, 5, 314, 158, 2, 1850, 1848, 3, 2, 2, 2, 1851, 1854, 3, 2, 2, 2, 1852, 1850, 3, 2, 2, 2, 1852, 1853, 3, 2, 2, 2, 1853, 1895, 3, 2, 2, 2, 1854, 1852, 3, 2, 2, 2, 1855, 1895, 7, 247, 2, 2, 1856, 1895, 7, 107, 2, 2, 1857, 1895, 7, 284, 2, 2, 1858, 1895, 7, 238, 2, 2, 1859, 1861, 7, 416, 2, 2, 1860, 1859, 3, 2, 2, 2, 1860, 1861, 3, 2, 2, 2, 1861, 1862, 3, 2, 2, 2, 1862, 1895, 7, 129, 2, 2, 1863, 1865, 7, 87, 2, 2, 1864, 1863, 3, 2, 2, 2, 1864, 1865, 3, 2, 2, 2, 1865, 1866, 3, 2, 2, 2, 1866, 1867, 7, 224, 2, 2, 1867, 1895, 9, 26, 2, 2, 1868, 1869, 7, 171, 2, 2, 1869, 1895, 9, 27, 2, 2, 1870, 1871, 7, 48, 2, 2, 1871, 1895, 5, 574, 288, 2, 1872, 1873, 7, 216, 2, 2, 1873, 1895, 5, 574, 288, 2, 1874, 1875, 7, 250, 2, 2, 1875, 1895, 5, 618, 310, 2, 1876, 1880, 7, 230, 2, 2, 1877, 1878, 5, 528, 265, 2, 1878, 1879, 7, 595, 2, 2, 1879, 1881, 3, 2, 2, 2, 1880, 1877, 3, 2, 2, 2, 1880, 1881, 3, 2, 2, 2, 1881, 1882, 3, 2, 2, 2, 1882, 1887, 5, 528, 265, 2, 1883, 1884, 9, 28, 2, 2, 1884, 1888, 5, 268, 135, 2, 1885, 1886, 7, 403, 2, 2, 1886, 1888, 7, 51, 2, 2, 1887, 1883, 3, 2, 2, 2, 1887, 1885, 3, 2, 2, 2, 1888, 1895, 3, 2, 2, 2, 1889, 1890, 7, 126, 2, 2, 1890, 1895, 5, 528, 265, 2, 1891, 1895, 7, 443, 2, 2, 1892, 1893, 7, 374, 2, 2, 1893, 1895, 5, 106, 54, 2, 1894, 1841, 3, 2, 2, 2, 1894, 1846, 3, 2, 2, 2, 1894, 1855, 3, 2, 2, 2, 1894, 1856, 3, 2, 2, 2, 1894, 1857, 3, 2, 2, 2, 1894, 1858, 3, 2, 2, 2, 1894, 1860, 3, 2, 2, 2, 1894, 1864, 3, 2, 2, 2, 1894, 1868, 3, 2, 2, 2, 1894, 1870, 3, 2, 2, 2, 1894, 1872, 3, 2, 2, 2, 1894, 1874, 3, 2, 2, 2, 1894, 1876, 3, 2, 2, 2, 1894, 1889, 3, 2, 2, 2, 1894, 1891, 3, 2, 2, 2, 1894, 1892, 3, 2, 2, 2, 1895, 105, 3, 2, 2, 2, 1896, 1899, 5, 326, 164, 2, 1897, 1898, 7, 581, 2, 2, 1898, 1900, 5, 326, 164, 2, 1899, 1897, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 107, 3, 2, 2, 2, 1901, 1903, 7, 113, 2, 2, 1902, 1904, 5, 408, 205, 2, 1903, 1902, 3, 2, 2, 2, 1903, 1904, 3, 2, 2, 2, 1904, 1905, 3, 2, 2, 2, 1905, 1906, 5, 618, 310, 2, 1906, 1907, 5, 110, 56, 2, 1907, 1925, 3, 2, 2, 2, 1908, 1909, 7, 113, 2, 2, 1909, 1910, 7, 368, 2, 2, 1910, 1911, 7, 407, 2, 2, 1911, 1912, 7, 254, 2, 2, 1912, 1916, 5, 528, 265, 2, 1913, 1914, 7, 169, 2, 2, 1914, 1915, 7, 22, 2, 2, 1915, 1917, 5, 694, 348, 2, 1916, 1913, 3, 2, 2, 2, 1916, 1917, 3, 2, 2, 2, 1917, 1918, 3, 2, 2, 2, 1918, 1919, 7, 230, 2, 2, 1919, 1920, 7, 254, 2, 2, 1920, 1922, 5, 528, 265, 2, 1921, 1923, 7, 155, 2, 2, 1922, 1921, 3, 2, 2, 2, 1922, 1923, 3, 2, 2, 2, 1923, 1925, 3, 2, 2, 2, 1924, 1901, 3, 2, 2, 2, 1924, 1908, 3, 2, 2, 2, 1925, 109, 3, 2, 2, 2, 1926, 1966, 5, 494, 248, 2, 1927, 1928, 7, 17, 2, 2, 1928, 1929, 7, 174, 2, 2, 1929, 1966, 5, 618, 310, 2, 1930, 1931, 7, 65, 2, 2, 1931, 1932, 7, 419, 2, 2, 1932, 1933, 7, 86, 2, 2, 1933, 1966, 5, 618, 310, 2, 1934, 1936, 7, 12, 2, 2, 1935, 1937, 7, 382, 2, 2, 1936, 1935, 3, 2, 2, 2, 1936, 1937, 3, 2, 2, 2, 1937, 1939, 3, 2, 2, 2, 1938, 1940, 5, 340, 171, 2, 1939, 1938, 3, 2, 2, 2, 1939, 1940, 3, 2, 2, 2, 1940, 1941, 3, 2, 2, 2, 1941, 1942, 7, 610, 2, 2, 1942, 1943, 7, 230, 2, 2, 1943, 1944, 7, 242, 2, 2, 1944, 1966, 5, 336, 169, 2, 1945, 1946, 7, 206, 2, 2, 1946, 1947, 7, 587, 2, 2, 1947, 1948, 5, 694, 348, 2, 1948, 1949, 7, 588, 2, 2, 1949, 1966, 3, 2, 2, 2, 1950, 1951, 7, 230, 2, 2, 1951, 1952, 7, 254, 2, 2, 1952, 1966, 5, 528, 265, 2, 1953, 1954, 7, 230, 2, 2, 1954, 1955, 7, 587, 2, 2, 1955, 1960, 5, 168, 85, 2, 1956, 1957, 7, 581, 2, 2, 1957, 1959, 5, 168, 85, 2, 1958, 1956, 3, 2, 2, 2, 1959, 1962, 3, 2, 2, 2, 1960, 1958, 3, 2, 2, 2, 1960, 1961, 3, 2, 2, 2, 1961, 1963, 3, 2, 2, 2, 1962, 1960, 3, 2, 2, 2, 1963, 1964, 7, 588, 2, 2, 1964, 1966, 3, 2, 2, 2, 1965, 1926, 3, 2, 2, 2, 1965, 1927, 3, 2, 2, 2, 1965, 1930, 3, 2, 2, 2, 1965, 1934, 3, 2, 2, 2, 1965, 1945, 3, 2, 2, 2, 1965, 1950, 3, 2, 2, 2, 1965, 1953, 3, 2, 2, 2, 1966, 111, 3, 2, 2, 2, 1967, 1968, 7, 391, 2, 2, 1968, 1972, 7, 184, 2, 2, 1969, 1970, 7, 401, 2, 2, 1970, 1971, 9, 29, 2, 2, 1971, 1973, 5, 694, 348, 2, 1972, 1969, 3, 2, 2, 2, 1972, 1973, 3, 2, 2, 2, 1973, 1977, 3, 2, 2, 2, 1974, 1975, 7, 407, 2, 2, 1975, 1976, 7, 219, 2, 2, 1976, 1978, 5, 694, 348, 2, 1977, 1974, 3, 2, 2, 2, 1977, 1978, 3, 2, 2, 2, 1978, 1979, 3, 2, 2, 2, 1979, 1980, 5, 114, 58, 2, 1980, 113, 3, 2, 2, 2, 1981, 1987, 7, 404, 2, 2, 1982, 1984, 7, 210, 2, 2, 1983, 1985, 5, 116, 59, 2, 1984, 1983, 3, 2, 2, 2, 1984, 1985, 3, 2, 2, 2, 1985, 1987, 3, 2, 2, 2, 1986, 1981, 3, 2, 2, 2, 1986, 1982, 3, 2, 2, 2, 1987, 2043, 3, 2, 2, 2, 1988, 1993, 5, 498, 250, 2, 1989, 1990, 7, 581, 2, 2, 1990, 1992, 5, 498, 250, 2, 1991, 1989, 3, 2, 2, 2, 1992, 1995, 3, 2, 2, 2, 1993, 1991, 3, 2, 2, 2, 1993, 1994, 3, 2, 2, 2, 1994, 1996, 3, 2, 2, 2, 1995, 1993, 3, 2, 2, 2, 1996, 1997, 7, 419, 2, 2, 1997, 1998, 7, 253, 2, 2, 1998, 2044, 3, 2, 2, 2, 1999, 2004, 5, 500, 251, 2, 2000, 2001, 7, 581, 2, 2, 2001, 2003, 5, 500, 251, 2, 2002, 2000, 3, 2, 2, 2, 2003, 2006, 3, 2, 2, 2, 2004, 2002, 3, 2, 2, 2, 2004, 2005, 3, 2, 2, 2, 2005, 2012, 3, 2, 2, 2, 2006, 2004, 3, 2, 2, 2, 2007, 2009, 7, 368, 2, 2, 2008, 2010, 7, 184, 2, 2, 2009, 2008, 3, 2, 2, 2, 2009, 2010, 3, 2, 2, 2, 2010, 2012, 3, 2, 2, 2, 2011, 1999, 3, 2, 2, 2, 2011, 2007, 3, 2, 2, 2, 2012, 2013, 3, 2, 2, 2, 2013, 2014, 7, 419, 2, 2, 2014, 2044, 7, 226, 2, 2, 2015, 2021, 7, 84, 2, 2, 2016, 2018, 7, 368, 2, 2, 2017, 2019, 7, 184, 2, 2, 2018, 2017, 3, 2, 2, 2, 2018, 2019, 3, 2, 2, 2, 2019, 2021, 3, 2, 2, 2, 2020, 2015, 3, 2, 2, 2, 2020, 2016, 3, 2, 2, 2, 2021, 2022, 3, 2, 2, 2, 2022, 2023, 7, 419, 2, 2, 2023, 2044, 7, 95, 2, 2, 2024, 2031, 7, 541, 2, 2, 2025, 2031, 7, 384, 2, 2, 2026, 2028, 7, 368, 2, 2, 2027, 2029, 7, 184, 2, 2, 2028, 2027, 3, 2, 2, 2, 2028, 2029, 3, 2, 2, 2, 2029, 2031, 3, 2, 2, 2, 2030, 2024, 3, 2, 2, 2, 2030, 2025, 3, 2, 2, 2, 2030, 2026, 3, 2, 2, 2, 2031, 2032, 3, 2, 2, 2, 2032, 2033, 7, 419, 2, 2, 2033, 2044, 7, 220, 2, 2, 2034, 2040, 7, 541, 2, 2, 2035, 2037, 7, 368, 2, 2, 2036, 2038, 7, 184, 2, 2, 2037, 2036, 3, 2, 2, 2, 2037, 2038, 3, 2, 2, 2, 2038, 2040, 3, 2, 2, 2, 2039, 2034, 3, 2, 2, 2, 2039, 2035, 3, 2, 2, 2, 2040, 2041, 3, 2, 2, 2, 2041, 2042, 7, 419, 2, 2, 2042, 2044, 7, 266, 2, 2, 2043, 1988, 3, 2, 2, 2, 2043, 2011, 3, 2, 2, 2, 2043, 2020, 3, 2, 2, 2, 2043, 2030, 3, 2, 2, 2, 2043, 2039, 3, 2, 2, 2, 2044, 2047, 3, 2, 2, 2, 2045, 2048, 5, 294, 148, 2, 2046, 2048, 5, 296, 149, 2, 2047, 2045, 3, 2, 2, 2, 2047, 2046, 3, 2, 2, 2, 2048, 115, 3, 2, 2, 2, 2049, 2050, 7, 404, 2, 2, 2050, 2051, 7, 163, 2, 2, 2051, 2052, 7, 401, 2, 2, 2052, 117, 3, 2, 2, 2, 2053, 2055, 7, 225, 2, 2, 2054, 2056, 5, 408, 205, 2, 2055, 2054, 3, 2, 2, 2, 2055, 2056, 3, 2, 2, 2, 2056, 2057, 3, 2, 2, 2, 2057, 2073, 5, 618, 310, 2, 2058, 2067, 5, 334, 168, 2, 2059, 2064, 7, 207, 2, 2, 2060, 2062, 7, 444, 2, 2, 2061, 2060, 3, 2, 2, 2, 2061, 2062, 3, 2, 2, 2, 2062, 2063, 3, 2, 2, 2, 2063, 2065, 5, 336, 169, 2, 2064, 2061, 3, 2, 2, 2, 2064, 2065, 3, 2, 2, 2, 2065, 2067, 3, 2, 2, 2, 2066, 2058, 3, 2, 2, 2, 2066, 2059, 3, 2, 2, 2, 2067, 2070, 3, 2, 2, 2, 2068, 2066, 3, 2, 2, 2, 2068, 2069, 3, 2, 2, 2, 2069, 2074, 3, 2, 2, 2, 2070, 2068, 3, 2, 2, 2, 2071, 2074, 5, 496, 249, 2, 2072, 2074, 5, 494, 248, 2, 2073, 2068, 3, 2, 2, 2, 2073, 2071, 3, 2, 2, 2, 2073, 2072, 3, 2, 2, 2, 2074, 119, 3, 2, 2, 2, 2075, 2077, 7, 140, 2, 2, 2076, 2075, 3, 2, 2, 2, 2076, 2077, 3, 2, 2, 2, 2077, 2078, 3, 2, 2, 2, 2078, 2080, 7, 282, 2, 2, 2079, 2081, 5, 408, 205, 2, 2080, 2079, 3, 2, 2, 2, 2080, 2081, 3, 2, 2, 2, 2081, 2082, 3, 2, 2, 2, 2082, 2098, 5, 618, 310, 2, 2083, 2085, 7, 12, 2, 2, 2084, 2086, 7, 382, 2, 2, 2085, 2084, 3, 2, 2, 2, 2085, 2086, 3, 2, 2, 2, 2086, 2087, 3, 2, 2, 2, 2087, 2090, 5, 618, 310, 2, 2088, 2091, 5, 140, 71, 2, 2089, 2091, 5, 142, 72, 2, 2090, 2088, 3, 2, 2, 2, 2090, 2089, 3, 2, 2, 2, 2091, 2099, 3, 2, 2, 2, 2092, 2099, 5, 496, 249, 2, 2093, 2099, 5, 494, 248, 2, 2094, 2095, 7, 230, 2, 2, 2095, 2099, 5, 476, 239, 2, 2096, 2097, 7, 206, 2, 2, 2097, 2099, 5, 472, 237, 2, 2098, 2083, 3, 2, 2, 2, 2098, 2092, 3, 2, 2, 2, 2098, 2093, 3, 2, 2, 2, 2098, 2094, 3, 2, 2, 2, 2098, 2096, 3, 2, 2, 2, 2099, 121, 3, 2, 2, 2, 2100, 2101, 7, 80, 2, 2, 2101, 2102, 7, 262, 2, 2, 2102, 2103, 5, 528, 265, 2, 2103, 2104, 5, 124, 63, 2, 2104, 123, 3, 2, 2, 2, 2105, 2113, 7, 68, 2, 2, 2106, 2108, 7, 75, 2, 2, 2107, 2109, 9, 21, 2, 2, 2108, 2107, 3, 2, 2, 2, 2108, 2109, 3, 2, 2, 2, 2109, 2113, 3, 2, 2, 2, 2110, 2113, 5, 492, 247, 2, 2111, 2113, 5, 494, 248, 2, 2112, 2105, 3, 2, 2, 2, 2112, 2106, 3, 2, 2, 2, 2112, 2110, 3, 2, 2, 2, 2112, 2111, 3, 2, 2, 2, 2113, 125, 3, 2, 2, 2, 2114, 2115, 7, 265, 2, 2, 2115, 2150, 5, 618, 310, 2, 2116, 2151, 5, 496, 249, 2, 2117, 2151, 5, 494, 248, 2, 2118, 2119, 7, 7, 2, 2, 2119, 2121, 7, 279, 2, 2, 2120, 2122, 5, 410, 206, 2, 2121, 2120, 3, 2, 2, 2, 2121, 2122, 3, 2, 2, 2, 2122, 2123, 3, 2, 2, 2, 2123, 2126, 5, 326, 164, 2, 2124, 2125, 9, 30, 2, 2, 2125, 2127, 5, 326, 164, 2, 2126, 2124, 3, 2, 2, 2, 2126, 2127, 3, 2, 2, 2, 2127, 2151, 3, 2, 2, 2, 2128, 2129, 7, 202, 2, 2, 2129, 2130, 7, 18, 2, 2, 2130, 2131, 5, 528, 265, 2, 2131, 2132, 7, 433, 2, 2, 2132, 2134, 5, 528, 265, 2, 2133, 2135, 5, 504, 253, 2, 2134, 2133, 3, 2, 2, 2, 2134, 2135, 3, 2, 2, 2, 2135, 2151, 3, 2, 2, 2, 2136, 2137, 7, 202, 2, 2, 2137, 2138, 7, 279, 2, 2, 2138, 2139, 5, 326, 164, 2, 2139, 2140, 7, 433, 2, 2, 2140, 2141, 5, 326, 164, 2, 2141, 2151, 3, 2, 2, 2, 2142, 2147, 5, 138, 70, 2, 2143, 2144, 7, 581, 2, 2, 2144, 2146, 5, 138, 70, 2, 2145, 2143, 3, 2, 2, 2, 2146, 2149, 3, 2, 2, 2, 2147, 2145, 3, 2, 2, 2, 2147, 2148, 3, 2, 2, 2, 2148, 2151, 3, 2, 2, 2, 2149, 2147, 3, 2, 2, 2, 2150, 2116, 3, 2, 2, 2, 2150, 2117, 3, 2, 2, 2, 2150, 2118, 3, 2, 2, 2, 2150, 2128, 3, 2, 2, 2, 2150, 2136, 3, 2, 2, 2, 2150, 2142, 3, 2, 2, 2, 2151, 127, 3, 2, 2, 2, 2152, 2153, 7, 71, 2, 2, 2153, 2175, 5, 618, 310, 2, 2154, 2176, 5, 140, 71, 2, 2155, 2176, 5, 142, 72, 2, 2156, 2157, 9, 31, 2, 2, 2157, 2158, 7, 416, 2, 2, 2158, 2176, 7, 417, 2, 2, 2159, 2160, 7, 7, 2, 2, 2160, 2163, 5, 222, 112, 2, 2161, 2162, 7, 416, 2, 2, 2162, 2164, 7, 276, 2, 2, 2163, 2161, 3, 2, 2, 2, 2163, 2164, 3, 2, 2, 2, 2164, 2176, 3, 2, 2, 2, 2165, 2176, 5, 98, 50, 2, 2166, 2167, 7, 202, 2, 2, 2167, 2168, 7, 383, 2, 2, 2168, 2169, 5, 618, 310, 2, 2169, 2170, 7, 433, 2, 2, 2170, 2171, 5, 618, 310, 2, 2171, 2176, 3, 2, 2, 2, 2172, 2176, 5, 96, 49, 2, 2173, 2176, 5, 494, 248, 2, 2174, 2176, 5, 496, 249, 2, 2175, 2154, 3, 2, 2, 2, 2175, 2155, 3, 2, 2, 2, 2175, 2156, 3, 2, 2, 2, 2175, 2159, 3, 2, 2, 2, 2175, 2165, 3, 2, 2, 2, 2175, 2166, 3, 2, 2, 2, 2175, 2172, 3, 2, 2, 2, 2175, 2173, 3, 2, 2, 2, 2175, 2174, 3, 2, 2, 2, 2176, 129, 3, 2, 2, 2, 2177, 2178, 7, 228, 2, 2, 2178, 2179, 5, 528, 265, 2, 2179, 2180, 5, 132, 67, 2, 2180, 131, 3, 2, 2, 2, 2181, 2182, 7, 281, 2, 2, 2182, 2184, 5, 326, 164, 2, 2183, 2181, 3, 2, 2, 2, 2183, 2184, 3, 2, 2, 2, 2184, 2185, 3, 2, 2, 2, 2185, 2191, 5, 444, 223, 2, 2186, 2187, 7, 281, 2, 2, 2187, 2191, 5, 326, 164, 2, 2188, 2191, 5, 492, 247, 2, 2189, 2191, 5, 494, 248, 2, 2190, 2183, 3, 2, 2, 2, 2190, 2186, 3, 2, 2, 2, 2190, 2188, 3, 2, 2, 2, 2190, 2189, 3, 2, 2, 2, 2191, 133, 3, 2, 2, 2, 2192, 2193, 7, 258, 2, 2, 2193, 2208, 7, 222, 2, 2, 2194, 2195, 9, 32, 2, 2, 2195, 2198, 5, 618, 310, 2, 2196, 2199, 5, 494, 248, 2, 2197, 2199, 5, 496, 249, 2, 2198, 2196, 3, 2, 2, 2, 2198, 2197, 3, 2, 2, 2, 2199, 2209, 3, 2, 2, 2, 2200, 2201, 7, 67, 2, 2, 2201, 2202, 5, 618, 310, 2, 2202, 2203, 5, 476, 239, 2, 2203, 2209, 3, 2, 2, 2, 2204, 2205, 7, 40, 2, 2, 2205, 2206, 5, 618, 310, 2, 2206, 2207, 5, 136, 69, 2, 2207, 2209, 3, 2, 2, 2, 2208, 2194, 3, 2, 2, 2, 2208, 2200, 3, 2, 2, 2, 2208, 2204, 3, 2, 2, 2, 2209, 135, 3, 2, 2, 2, 2210, 2211, 9, 33, 2, 2, 2211, 2212, 7, 138, 2, 2, 2212, 2213, 7, 401, 2, 2, 2213, 2214, 5, 694, 348, 2, 2214, 2215, 7, 444, 2, 2, 2215, 2220, 5, 618, 310, 2, 2216, 2217, 7, 581, 2, 2, 2217, 2219, 5, 618, 310, 2, 2218, 2216, 3, 2, 2, 2, 2219, 2222, 3, 2, 2, 2, 2220, 2218, 3, 2, 2, 2, 2220, 2221, 3, 2, 2, 2, 2221, 2243, 3, 2, 2, 2, 2222, 2220, 3, 2, 2, 2, 2223, 2224, 7, 12, 2, 2, 2224, 2227, 7, 138, 2, 2, 2225, 2226, 7, 401, 2, 2, 2226, 2228, 5, 694, 348, 2, 2227, 2225, 3, 2, 2, 2, 2227, 2228, 3, 2, 2, 2, 2228, 2229, 3, 2, 2, 2, 2229, 2230, 7, 204, 2, 2, 2230, 2231, 5, 618, 310, 2, 2231, 2232, 7, 444, 2, 2, 2232, 2233, 5, 618, 310, 2, 2233, 2243, 3, 2, 2, 2, 2234, 2235, 7, 73, 2, 2, 2235, 2238, 7, 138, 2, 2, 2236, 2237, 7, 105, 2, 2, 2237, 2239, 7, 304, 2, 2, 2238, 2236, 3, 2, 2, 2, 2238, 2239, 3, 2, 2, 2, 2239, 2240, 3, 2, 2, 2, 2240, 2241, 7, 401, 2, 2, 2241, 2243, 5, 694, 348, 2, 2242, 2210, 3, 2, 2, 2, 2242, 2223, 3, 2, 2, 2, 2242, 2234, 3, 2, 2, 2, 2243, 137, 3, 2, 2, 2, 2244, 2245, 7, 7, 2, 2, 2245, 2246, 7, 18, 2, 2, 2246, 2247, 5, 528, 265, 2, 2247, 2249, 5, 548, 275, 2, 2248, 2250, 5, 506, 254, 2, 2249, 2248, 3, 2, 2, 2, 2249, 2250, 3, 2, 2, 2, 2250, 2252, 3, 2, 2, 2, 2251, 2253, 5, 504, 253, 2, 2252, 2251, 3, 2, 2, 2, 2252, 2253, 3, 2, 2, 2, 2253, 2279, 3, 2, 2, 2, 2254, 2255, 7, 73, 2, 2, 2255, 2257, 7, 18, 2, 2, 2256, 2258, 5, 408, 205, 2, 2257, 2256, 3, 2, 2, 2, 2257, 2258, 3, 2, 2, 2, 2258, 2259, 3, 2, 2, 2, 2259, 2261, 5, 528, 265, 2, 2260, 2262, 5, 504, 253, 2, 2261, 2260, 3, 2, 2, 2, 2261, 2262, 3, 2, 2, 2, 2262, 2279, 3, 2, 2, 2, 2263, 2264, 7, 12, 2, 2, 2264, 2265, 7, 18, 2, 2, 2265, 2268, 5, 528, 265, 2, 2266, 2267, 7, 230, 2, 2, 2267, 2269, 7, 54, 2, 2, 2268, 2266, 3, 2, 2, 2, 2268, 2269, 3, 2, 2, 2, 2269, 2270, 3, 2, 2, 2, 2270, 2271, 7, 265, 2, 2, 2271, 2273, 5, 548, 275, 2, 2272, 2274, 5, 506, 254, 2, 2273, 2272, 3, 2, 2, 2, 2273, 2274, 3, 2, 2, 2, 2274, 2276, 3, 2, 2, 2, 2275, 2277, 5, 504, 253, 2, 2276, 2275, 3, 2, 2, 2, 2276, 2277, 3, 2, 2, 2, 2277, 2279, 3, 2, 2, 2, 2278, 2244, 3, 2, 2, 2, 2278, 2254, 3, 2, 2, 2, 2278, 2263, 3, 2, 2, 2, 2279, 139, 3, 2, 2, 2, 2280, 2281, 7, 230, 2, 2, 2281, 2282, 7, 391, 2, 2, 2282, 2283, 5, 560, 281, 2, 2283, 141, 3, 2, 2, 2, 2284, 2285, 7, 73, 2, 2, 2285, 2286, 7, 391, 2, 2, 2286, 143, 3, 2, 2, 2, 2287, 2289, 7, 437, 2, 2, 2288, 2287, 3, 2, 2, 2, 2288, 2289, 3, 2, 2, 2, 2289, 2290, 3, 2, 2, 2, 2290, 2292, 7, 113, 2, 2, 2291, 2293, 7, 348, 2, 2, 2292, 2291, 3, 2, 2, 2, 2292, 2293, 3, 2, 2, 2, 2293, 2295, 3, 2, 2, 2, 2294, 2296, 5, 410, 206, 2, 2295, 2294, 3, 2, 2, 2, 2295, 2296, 3, 2, 2, 2, 2296, 2298, 3, 2, 2, 2, 2297, 2299, 5, 528, 265, 2, 2298, 2297, 3, 2, 2, 2, 2298, 2299, 3, 2, 2, 2, 2299, 2300, 3, 2, 2, 2, 2300, 2302, 7, 419, 2, 2, 2301, 2303, 7, 420, 2, 2, 2302, 2301, 3, 2, 2, 2, 2302, 2303, 3, 2, 2, 2, 2303, 2304, 3, 2, 2, 2, 2304, 2305, 5, 618, 310, 2, 2305, 2306, 5, 146, 74, 2, 2306, 145, 3, 2, 2, 2, 2307, 2308, 7, 439, 2, 2, 2308, 2310, 5, 528, 265, 2, 2309, 2307, 3, 2, 2, 2, 2309, 2310, 3, 2, 2, 2, 2310, 2311, 3, 2, 2, 2, 2311, 2313, 5, 148, 75, 2, 2312, 2314, 5, 150, 76, 2, 2313, 2312, 3, 2, 2, 2, 2313, 2314, 3, 2, 2, 2, 2314, 2316, 3, 2, 2, 2, 2315, 2317, 5, 482, 242, 2, 2316, 2315, 3, 2, 2, 2, 2316, 2317, 3, 2, 2, 2, 2317, 2319, 3, 2, 2, 2, 2318, 2320, 5, 488, 245, 2, 2319, 2318, 3, 2, 2, 2, 2319, 2320, 3, 2, 2, 2, 2320, 2322, 3, 2, 2, 2, 2321, 2323, 5, 152, 77, 2, 2322, 2321, 3, 2, 2, 2, 2322, 2323, 3, 2, 2, 2, 2323, 147, 3, 2, 2, 2, 2324, 2325, 7, 587, 2, 2, 2325, 2326, 5, 666, 334, 2, 2326, 2327, 7, 588, 2, 2, 2327, 149, 3, 2, 2, 2, 2328, 2329, 7, 110, 2, 2, 2329, 2330, 7, 587, 2, 2, 2330, 2335, 5, 528, 265, 2, 2331, 2332, 7, 581, 2, 2, 2332, 2334, 5, 528, 265, 2, 2333, 2331, 3, 2, 2, 2, 2334, 2337, 3, 2, 2, 2, 2335, 2333, 3, 2, 2, 2, 2335, 2336, 3, 2, 2, 2, 2336, 2338, 3, 2, 2, 2, 2337, 2335, 3, 2, 2, 2, 2338, 2339, 7, 588, 2, 2, 2339, 151, 3, 2, 2, 2, 2340, 2341, 7, 442, 2, 2, 2341, 2342, 5, 560, 281, 2, 2342, 153, 3, 2, 2, 2, 2343, 2345, 7, 86, 2, 2, 2344, 2346, 5, 410, 206, 2, 2345, 2344, 3, 2, 2, 2, 2345, 2346, 3, 2, 2, 2, 2346, 2347, 3, 2, 2, 2, 2347, 2349, 5, 528, 265, 2, 2348, 2350, 7, 444, 2, 2, 2349, 2348, 3, 2, 2, 2, 2349, 2350, 3, 2, 2, 2, 2350, 2353, 3, 2, 2, 2, 2351, 2352, 7, 219, 2, 2, 2352, 2354, 5, 528, 265, 2, 2353, 2351, 3, 2, 2, 2, 2353, 2354, 3, 2, 2, 2, 2354, 2360, 3, 2, 2, 2, 2355, 2358, 7, 281, 2, 2, 2356, 2359, 5, 528, 265, 2, 2357, 2359, 5, 326, 164, 2, 2358, 2356, 3, 2, 2, 2, 2358, 2357, 3, 2, 2, 2, 2359, 2361, 3, 2, 2, 2, 2360, 2355, 3, 2, 2, 2, 2360, 2361, 3, 2, 2, 2, 2361, 2367, 3, 2, 2, 2, 2362, 2365, 7, 403, 2, 2, 2363, 2366, 5, 528, 265, 2, 2364, 2366, 5, 326, 164, 2, 2365, 2363, 3, 2, 2, 2, 2365, 2364, 3, 2, 2, 2, 2366, 2368, 3, 2, 2, 2, 2367, 2362, 3, 2, 2, 2, 2367, 2368, 3, 2, 2, 2, 2368, 2370, 3, 2, 2, 2, 2369, 2371, 7, 26, 2, 2, 2370, 2369, 3, 2, 2, 2, 2370, 2371, 3, 2, 2, 2, 2371, 155, 3, 2, 2, 2, 2372, 2373, 7, 421, 2, 2, 2373, 2375, 7, 204, 2, 2, 2374, 2372, 3, 2, 2, 2, 2374, 2375, 3, 2, 2, 2, 2375, 2377, 3, 2, 2, 2, 2376, 2378, 7, 264, 2, 2, 2377, 2376, 3, 2, 2, 2, 2377, 2378, 3, 2, 2, 2, 2378, 2380, 3, 2, 2, 2, 2379, 2381, 7, 185, 2, 2, 2380, 2379, 3, 2, 2, 2, 2380, 2381, 3, 2, 2, 2, 2381, 2382, 3, 2, 2, 2, 2382, 2383, 7, 126, 2, 2, 2383, 2394, 5, 528, 265, 2, 2384, 2385, 7, 100, 2, 2, 2385, 2388, 5, 618, 310, 2, 2386, 2387, 7, 117, 2, 2, 2387, 2389, 5, 618, 310, 2, 2388, 2386, 3, 2, 2, 2, 2388, 2389, 3, 2, 2, 2, 2389, 2392, 3, 2, 2, 2, 2390, 2391, 7, 278, 2, 2, 2391, 2393, 5, 618, 310, 2, 2392, 2390, 3, 2, 2, 2, 2392, 2393, 3, 2, 2, 2, 2393, 2395, 3, 2, 2, 2, 2394, 2384, 3, 2, 2, 2, 2394, 2395, 3, 2, 2, 2, 2395, 157, 3, 2, 2, 2, 2396, 2397, 7, 80, 2, 2, 2397, 2398, 7, 262, 2, 2, 2398, 2399, 5, 528, 265, 2, 2399, 2400, 7, 419, 2, 2, 2400, 2421, 5, 528, 265, 2, 2401, 2417, 7, 441, 2, 2, 2402, 2403, 5, 618, 310, 2, 2403, 2404, 7, 407, 2, 2, 2404, 2405, 7, 587, 2, 2, 2405, 2410, 5, 326, 164, 2, 2406, 2407, 7, 581, 2, 2, 2407, 2409, 5, 326, 164, 2, 2408, 2406, 3, 2, 2, 2, 2409, 2412, 3, 2, 2, 2, 2410, 2408, 3, 2, 2, 2, 2410, 2411, 3, 2, 2, 2, 2411, 2413, 3, 2, 2, 2, 2412, 2410, 3, 2, 2, 2, 2413, 2415, 7, 588, 2, 2, 2414, 2416, 7, 371, 2, 2, 2415, 2414, 3, 2, 2, 2, 2415, 2416, 3, 2, 2, 2, 2416, 2418, 3, 2, 2, 2, 2417, 2402, 3, 2, 2, 2, 2418, 2419, 3, 2, 2, 2, 2419, 2417, 3, 2, 2, 2, 2419, 2420, 3, 2, 2, 2, 2420, 2422, 3, 2, 2, 2, 2421, 2401, 3, 2, 2, 2, 2421, 2422, 3, 2, 2, 2, 2422, 2423, 3, 2, 2, 2, 2423, 2424, 7, 84, 2, 2, 2424, 2425, 9, 18, 2, 2, 2425, 2426, 5, 560, 281, 2, 2426, 159, 3, 2, 2, 2, 2427, 2428, 7, 265, 2, 2, 2428, 2576, 5, 618, 310, 2, 2429, 2498, 7, 374, 2, 2, 2430, 2439, 7, 587, 2, 2, 2431, 2436, 5, 456, 229, 2, 2432, 2433, 7, 581, 2, 2, 2433, 2435, 5, 456, 229, 2, 2434, 2432, 3, 2, 2, 2, 2435, 2438, 3, 2, 2, 2, 2436, 2434, 3, 2, 2, 2, 2436, 2437, 3, 2, 2, 2, 2437, 2440, 3, 2, 2, 2, 2438, 2436, 3, 2, 2, 2, 2439, 2431, 3, 2, 2, 2, 2439, 2440, 3, 2, 2, 2, 2440, 2441, 3, 2, 2, 2, 2441, 2499, 7, 588, 2, 2, 2442, 2443, 7, 78, 2, 2, 2443, 2452, 7, 587, 2, 2, 2444, 2449, 5, 326, 164, 2, 2445, 2446, 7, 581, 2, 2, 2446, 2448, 5, 326, 164, 2, 2447, 2445, 3, 2, 2, 2, 2448, 2451, 3, 2, 2, 2, 2449, 2447, 3, 2, 2, 2, 2449, 2450, 3, 2, 2, 2, 2450, 2453, 3, 2, 2, 2, 2451, 2449, 3, 2, 2, 2, 2452, 2444, 3, 2, 2, 2, 2452, 2453, 3, 2, 2, 2, 2453, 2454, 3, 2, 2, 2, 2454, 2499, 7, 588, 2, 2, 2455, 2456, 7, 191, 2, 2, 2456, 2472, 7, 587, 2, 2, 2457, 2458, 7, 534, 2, 2, 2458, 2459, 7, 578, 2, 2, 2459, 2473, 5, 548, 275, 2, 2460, 2461, 7, 533, 2, 2, 2461, 2462, 7, 578, 2, 2, 2462, 2473, 5, 528, 265, 2, 2463, 2464, 7, 347, 2, 2, 2464, 2465, 7, 578, 2, 2, 2465, 2473, 5, 618, 310, 2, 2466, 2467, 7, 449, 2, 2, 2467, 2468, 7, 578, 2, 2, 2468, 2473, 5, 618, 310, 2, 2469, 2470, 7, 532, 2, 2, 2470, 2471, 7, 578, 2, 2, 2471, 2473, 5, 618, 310, 2, 2472, 2457, 3, 2, 2, 2, 2472, 2460, 3, 2, 2, 2, 2472, 2463, 3, 2, 2, 2, 2472, 2466, 3, 2, 2, 2, 2472, 2469, 3, 2, 2, 2, 2472, 2473, 3, 2, 2, 2, 2473, 2494, 3, 2, 2, 2, 2474, 2490, 7, 581, 2, 2, 2475, 2476, 7, 534, 2, 2, 2476, 2477, 7, 578, 2, 2, 2477, 2491, 5, 548, 275, 2, 2478, 2479, 7, 533, 2, 2, 2479, 2480, 7, 578, 2, 2, 2480, 2491, 5, 528, 265, 2, 2481, 2482, 7, 347, 2, 2, 2482, 2483, 7, 578, 2, 2, 2483, 2491, 5, 618, 310, 2, 2484, 2485, 7, 449, 2, 2, 2485, 2486, 7, 578, 2, 2, 2486, 2491, 5, 618, 310, 2, 2487, 2488, 7, 532, 2, 2, 2488, 2489, 7, 578, 2, 2, 2489, 2491, 5, 618, 310, 2, 2490, 2475, 3, 2, 2, 2, 2490, 2478, 3, 2, 2, 2, 2490, 2481, 3, 2, 2, 2, 2490, 2484, 3, 2, 2, 2, 2490, 2487, 3, 2, 2, 2, 2491, 2493, 3, 2, 2, 2, 2492, 2474, 3, 2, 2, 2, 2493, 2496, 3, 2, 2, 2, 2494, 2492, 3, 2, 2, 2, 2494, 2495, 3, 2, 2, 2, 2495, 2497, 3, 2, 2, 2, 2496, 2494, 3, 2, 2, 2, 2497, 2499, 7, 588, 2, 2, 2498, 2430, 3, 2, 2, 2, 2498, 2442, 3, 2, 2, 2, 2498, 2455, 3, 2, 2, 2, 2499, 2577, 3, 2, 2, 2, 2500, 2508, 7, 587, 2, 2, 2501, 2502, 7, 478, 2, 2, 2502, 2505, 7, 578, 2, 2, 2503, 2506, 5, 338, 170, 2, 2504, 2506, 7, 542, 2, 2, 2505, 2503, 3, 2, 2, 2, 2505, 2504, 3, 2, 2, 2, 2506, 2507, 3, 2, 2, 2, 2507, 2509, 7, 581, 2, 2, 2508, 2501, 3, 2, 2, 2, 2508, 2509, 3, 2, 2, 2, 2509, 2510, 3, 2, 2, 2, 2510, 2511, 7, 118, 2, 2, 2511, 2512, 7, 578, 2, 2, 2512, 2513, 5, 618, 310, 2, 2513, 2514, 7, 581, 2, 2, 2514, 2515, 7, 507, 2, 2, 2515, 2516, 7, 578, 2, 2, 2516, 2571, 5, 618, 310, 2, 2517, 2567, 7, 581, 2, 2, 2518, 2519, 7, 516, 2, 2, 2519, 2520, 7, 578, 2, 2, 2520, 2568, 5, 618, 310, 2, 2521, 2522, 7, 523, 2, 2, 2522, 2523, 7, 578, 2, 2, 2523, 2568, 5, 618, 310, 2, 2524, 2525, 7, 538, 2, 2, 2525, 2526, 7, 578, 2, 2, 2526, 2568, 5, 618, 310, 2, 2527, 2528, 7, 539, 2, 2, 2528, 2529, 7, 578, 2, 2, 2529, 2568, 5, 618, 310, 2, 2530, 2531, 7, 370, 2, 2, 2531, 2532, 7, 578, 2, 2, 2532, 2568, 5, 618, 310, 2, 2533, 2534, 7, 478, 2, 2, 2534, 2537, 7, 578, 2, 2, 2535, 2538, 5, 338, 170, 2, 2536, 2538, 7, 542, 2, 2, 2537, 2535, 3, 2, 2, 2, 2537, 2536, 3, 2, 2, 2, 2538, 2568, 3, 2, 2, 2, 2539, 2568, 7, 508, 2, 2, 2540, 2541, 7, 445, 2, 2, 2541, 2542, 7, 578, 2, 2, 2542, 2568, 5, 548, 275, 2, 2543, 2544, 7, 245, 2, 2, 2544, 2545, 7, 578, 2, 2, 2545, 2568, 9, 24, 2, 2, 2546, 2547, 7, 359, 2, 2, 2547, 2548, 7, 578, 2, 2, 2548, 2568, 5, 548, 275, 2, 2549, 2550, 7, 450, 2, 2, 2550, 2551, 7, 578, 2, 2, 2551, 2568, 5, 326, 164, 2, 2552, 2553, 7, 512, 2, 2, 2553, 2554, 7, 578, 2, 2, 2554, 2568, 5, 576, 289, 2, 2555, 2556, 7, 391, 2, 2, 2556, 2557, 7, 578, 2, 2, 2557, 2568, 5, 560, 281, 2, 2558, 2559, 7, 461, 2, 2, 2559, 2560, 7, 578, 2, 2, 2560, 2568, 5, 548, 275, 2, 2561, 2562, 7, 63, 2, 2, 2562, 2563, 7, 578, 2, 2, 2563, 2568, 5, 326, 164, 2, 2564, 2565, 7, 451, 2, 2, 2565, 2566, 7, 578, 2, 2, 2566, 2568, 5, 576, 289, 2, 2567, 2518, 3, 2, 2, 2, 2567, 2521, 3, 2, 2, 2, 2567, 2524, 3, 2, 2, 2, 2567, 2527, 3, 2, 2, 2, 2567, 2530, 3, 2, 2, 2, 2567, 2533, 3, 2, 2, 2, 2567, 2539, 3, 2, 2, 2, 2567, 2540, 3, 2, 2, 2, 2567, 2543, 3, 2, 2, 2, 2567, 2546, 3, 2, 2, 2, 2567, 2549, 3, 2, 2, 2, 2567, 2552, 3, 2, 2, 2, 2567, 2555, 3, 2, 2, 2, 2567, 2558, 3, 2, 2, 2, 2567, 2561, 3, 2, 2, 2, 2567, 2564, 3, 2, 2, 2, 2568, 2570, 3, 2, 2, 2, 2569, 2517, 3, 2, 2, 2, 2570, 2573, 3, 2, 2, 2, 2571, 2569, 3, 2, 2, 2, 2571, 2572, 3, 2, 2, 2, 2572, 2574, 3, 2, 2, 2, 2573, 2571, 3, 2, 2, 2, 2574, 2575, 7, 588, 2, 2, 2575, 2577, 3, 2, 2, 2, 2576, 2429, 3, 2, 2, 2, 2576, 2500, 3, 2, 2, 2, 2576, 2577, 3, 2, 2, 2, 2577, 161, 3, 2, 2, 2, 2578, 2579, 7, 71, 2, 2, 2579, 2581, 5, 618, 310, 2, 2580, 2582, 7, 374, 2, 2, 2581, 2580, 3, 2, 2, 2, 2581, 2582, 3, 2, 2, 2, 2582, 2583, 3, 2, 2, 2, 2583, 2590, 5, 548, 275, 2, 2584, 2589, 5, 506, 254, 2, 2585, 2586, 7, 391, 2, 2, 2586, 2589, 5, 560, 281, 2, 2587, 2589, 5, 222, 112, 2, 2588, 2584, 3, 2, 2, 2, 2588, 2585, 3, 2, 2, 2, 2588, 2587, 3, 2, 2, 2, 2589, 2592, 3, 2, 2, 2, 2590, 2588, 3, 2, 2, 2, 2590, 2591, 3, 2, 2, 2, 2591, 163, 3, 2, 2, 2, 2592, 2590, 3, 2, 2, 2, 2593, 2595, 7, 228, 2, 2, 2594, 2596, 5, 410, 206, 2, 2595, 2594, 3, 2, 2, 2, 2595, 2596, 3, 2, 2, 2, 2596, 2597, 3, 2, 2, 2, 2597, 2600, 5, 528, 265, 2, 2598, 2599, 7, 265, 2, 2, 2599, 2601, 5, 326, 164, 2, 2600, 2598, 3, 2, 2, 2, 2600, 2601, 3, 2, 2, 2, 2601, 2604, 3, 2, 2, 2, 2602, 2603, 7, 281, 2, 2, 2603, 2605, 5, 326, 164, 2, 2604, 2602, 3, 2, 2, 2, 2604, 2605, 3, 2, 2, 2, 2605, 2606, 3, 2, 2, 2, 2606, 2607, 7, 402, 2, 2, 2607, 2608, 7, 54, 2, 2, 2608, 2609, 7, 289, 2, 2, 2609, 2611, 5, 528, 265, 2, 2610, 2612, 5, 444, 223, 2, 2611, 2610, 3, 2, 2, 2, 2611, 2612, 3, 2, 2, 2, 2612, 165, 3, 2, 2, 2, 2613, 2614, 7, 258, 2, 2, 2614, 2615, 7, 222, 2, 2, 2615, 2616, 7, 67, 2, 2, 2616, 2617, 5, 618, 310, 2, 2617, 2618, 7, 587, 2, 2, 2618, 2619, 7, 256, 2, 2, 2619, 2620, 7, 578, 2, 2, 2620, 2625, 5, 618, 310, 2, 2621, 2622, 7, 581, 2, 2, 2622, 2624, 5, 168, 85, 2, 2623, 2621, 3, 2, 2, 2, 2624, 2627, 3, 2, 2, 2, 2625, 2623, 3, 2, 2, 2, 2625, 2626, 3, 2, 2, 2, 2626, 2628, 3, 2, 2, 2, 2627, 2625, 3, 2, 2, 2, 2628, 2629, 7, 588, 2, 2, 2629, 167, 3, 2, 2, 2, 2630, 2631, 5, 528, 265, 2, 2631, 2632, 7, 578, 2, 2, 2632, 2633, 5, 560, 281, 2, 2633, 169, 3, 2, 2, 2, 2634, 2635, 7, 258, 2, 2, 2635, 2636, 7, 222, 2, 2, 2636, 2637, 7, 40, 2, 2, 2637, 2638, 5, 618, 310, 2, 2638, 2645, 7, 587, 2, 2, 2639, 2640, 7, 172, 2, 2, 2640, 2641, 7, 578, 2, 2, 2641, 2646, 5, 618, 310, 2, 2642, 2643, 7, 47, 2, 2, 2643, 2644, 7, 578, 2, 2, 2644, 2646, 5, 618, 310, 2, 2645, 2639, 3, 2, 2, 2, 2645, 2642, 3, 2, 2, 2, 2646, 2647, 3, 2, 2, 2, 2647, 2648, 7, 588, 2, 2, 2648, 171, 3, 2, 2, 2, 2649, 2650, 7, 258, 2, 2, 2650, 2651, 7, 222, 2, 2, 2651, 2652, 7, 256, 2, 2, 2652, 2653, 5, 618, 310, 2, 2653, 2659, 7, 587, 2, 2, 2654, 2655, 7, 476, 2, 2, 2655, 2656, 7, 578, 2, 2, 2656, 2657, 5, 618, 310, 2, 2657, 2658, 7, 581, 2, 2, 2658, 2660, 3, 2, 2, 2, 2659, 2654, 3, 2, 2, 2, 2659, 2660, 3, 2, 2, 2, 2660, 2661, 3, 2, 2, 2, 2661, 2662, 7, 483, 2, 2, 2662, 2663, 7, 578, 2, 2, 2663, 2668, 5, 618, 310, 2, 2664, 2665, 7, 581, 2, 2, 2665, 2666, 7, 476, 2, 2, 2666, 2667, 7, 578, 2, 2, 2667, 2669, 5, 618, 310, 2, 2668, 2664, 3, 2, 2, 2, 2668, 2669, 3, 2, 2, 2, 2669, 2670, 3, 2, 2, 2, 2670, 2671, 7, 588, 2, 2, 2671, 173, 3, 2, 2, 2, 2672, 2673, 7, 258, 2, 2, 2673, 2674, 7, 222, 2, 2, 2674, 2675, 7, 172, 2, 2, 2675, 2676, 5, 618, 310, 2, 2676, 2677, 7, 587, 2, 2, 2677, 2678, 7, 240, 2, 2, 2678, 2679, 7, 578, 2, 2, 2679, 2680, 5, 618, 310, 2, 2680, 2681, 7, 581, 2, 2, 2681, 2682, 7, 470, 2, 2, 2682, 2683, 7, 578, 2, 2, 2683, 2684, 5, 618, 310, 2, 2684, 2685, 7, 581, 2, 2, 2685, 2686, 7, 397, 2, 2, 2686, 2687, 7, 578, 2, 2, 2687, 2688, 5, 618, 310, 2, 2688, 2694, 7, 581, 2, 2, 2689, 2690, 7, 473, 2, 2, 2690, 2691, 7, 578, 2, 2, 2691, 2692, 5, 618, 310, 2, 2692, 2693, 7, 581, 2, 2, 2693, 2695, 3, 2, 2, 2, 2694, 2689, 3, 2, 2, 2, 2694, 2695, 3, 2, 2, 2, 2695, 2696, 3, 2, 2, 2, 2696, 2697, 7, 484, 2, 2, 2697, 2698, 7, 578, 2, 2, 2698, 2703, 5, 618, 310, 2, 2699, 2700, 7, 581, 2, 2, 2700, 2701, 7, 473, 2, 2, 2701, 2702, 7, 578, 2, 2, 2702, 2704, 5, 618, 310, 2, 2703, 2699, 3, 2, 2, 2, 2703, 2704, 3, 2, 2, 2, 2704, 2705, 3, 2, 2, 2, 2705, 2706, 7, 588, 2, 2, 2706, 175, 3, 2, 2, 2, 2707, 2709, 7, 347, 2, 2, 2708, 2710, 5, 410, 206, 2, 2709, 2708, 3, 2, 2, 2, 2709, 2710, 3, 2, 2, 2, 2710, 2711, 3, 2, 2, 2, 2711, 2726, 5, 618, 310, 2, 2712, 2713, 7, 403, 2, 2, 2713, 2727, 5, 618, 310, 2, 2714, 2723, 7, 587, 2, 2, 2715, 2720, 5, 180, 91, 2, 2716, 2717, 7, 581, 2, 2, 2717, 2719, 5, 180, 91, 2, 2718, 2716, 3, 2, 2, 2, 2719, 2722, 3, 2, 2, 2, 2720, 2718, 3, 2, 2, 2, 2720, 2721, 3, 2, 2, 2, 2721, 2724, 3, 2, 2, 2, 2722, 2720, 3, 2, 2, 2, 2723, 2715, 3, 2, 2, 2, 2723, 2724, 3, 2, 2, 2, 2724, 2725, 3, 2, 2, 2, 2725, 2727, 7, 588, 2, 2, 2726, 2712, 3, 2, 2, 2, 2726, 2714, 3, 2, 2, 2, 2727, 177, 3, 2, 2, 2, 2728, 2729, 7, 347, 2, 2, 2729, 2735, 5, 618, 310, 2, 2730, 2731, 7, 198, 2, 2, 2731, 2736, 7, 281, 2, 2, 2732, 2736, 5, 494, 248, 2, 2733, 2736, 5, 492, 247, 2, 2734, 2736, 5, 496, 249, 2, 2735, 2730, 3, 2, 2, 2, 2735, 2732, 3, 2, 2, 2, 2735, 2733, 3, 2, 2, 2, 2735, 2734, 3, 2, 2, 2, 2736, 179, 3, 2, 2, 2, 2737, 2738, 9, 34, 2, 2, 2738, 2741, 7, 578, 2, 2, 2739, 2742, 5, 326, 164, 2, 2740, 2742, 5, 528, 265, 2, 2741, 2739, 3, 2, 2, 2, 2741, 2740, 3, 2, 2, 2, 2742, 2747, 3, 2, 2, 2, 2743, 2744, 7, 459, 2, 2, 2744, 2745, 7, 578, 2, 2, 2745, 2747, 5, 56, 29, 2, 2746, 2737, 3, 2, 2, 2, 2746, 2743, 3, 2, 2, 2, 2747, 181, 3, 2, 2, 2, 2748, 2749, 7, 438, 2, 2, 2749, 2751, 7, 138, 2, 2, 2750, 2752, 5, 410, 206, 2, 2751, 2750, 3, 2, 2, 2, 2751, 2752, 3, 2, 2, 2, 2752, 2753, 3, 2, 2, 2, 2753, 2756, 7, 401, 2, 2, 2754, 2757, 5, 44, 23, 2, 2755, 2757, 7, 438, 2, 2, 2756, 2754, 3, 2, 2, 2, 2756, 2755, 3, 2, 2, 2, 2757, 2758, 3, 2, 2, 2, 2758, 2759, 7, 228, 2, 2, 2759, 2761, 5, 528, 265, 2, 2760, 2762, 5, 444, 223, 2, 2761, 2760, 3, 2, 2, 2, 2761, 2762, 3, 2, 2, 2, 2762, 183, 3, 2, 2, 2, 2763, 2764, 7, 438, 2, 2, 2764, 2765, 7, 138, 2, 2, 2765, 2768, 7, 401, 2, 2, 2766, 2769, 5, 44, 23, 2, 2767, 2769, 7, 438, 2, 2, 2768, 2766, 3, 2, 2, 2, 2768, 2767, 3, 2, 2, 2, 2769, 2770, 3, 2, 2, 2, 2770, 2771, 7, 228, 2, 2, 2771, 2773, 5, 528, 265, 2, 2772, 2774, 5, 444, 223, 2, 2773, 2772, 3, 2, 2, 2, 2773, 2774, 3, 2, 2, 2, 2774, 185, 3, 2, 2, 2, 2775, 2789, 9, 29, 2, 2, 2776, 2790, 5, 188, 95, 2, 2777, 2778, 5, 528, 265, 2, 2778, 2779, 5, 494, 248, 2, 2779, 2790, 3, 2, 2, 2, 2780, 2782, 5, 44, 23, 2, 2781, 2783, 7, 444, 2, 2, 2782, 2781, 3, 2, 2, 2, 2782, 2783, 3, 2, 2, 2, 2783, 2785, 3, 2, 2, 2, 2784, 2786, 5, 232, 117, 2, 2785, 2784, 3, 2, 2, 2, 2786, 2787, 3, 2, 2, 2, 2787, 2785, 3, 2, 2, 2, 2787, 2788, 3, 2, 2, 2, 2788, 2790, 3, 2, 2, 2, 2789, 2776, 3, 2, 2, 2, 2789, 2777, 3, 2, 2, 2, 2789, 2780, 3, 2, 2, 2, 2790, 187, 3, 2, 2, 2, 2791, 2794, 5, 44, 23, 2, 2792, 2794, 7, 368, 2, 2, 2793, 2791, 3, 2, 2, 2, 2793, 2792, 3, 2, 2, 2, 2794, 2798, 3, 2, 2, 2, 2795, 2796, 7, 407, 2, 2, 2796, 2797, 7, 55, 2, 2, 2797, 2799, 5, 528, 265, 2, 2798, 2795, 3, 2, 2, 2, 2798, 2799, 3, 2, 2, 2, 2799, 2800, 3, 2, 2, 2, 2800, 2801, 5, 190, 96, 2, 2801, 189, 3, 2, 2, 2, 2802, 2806, 7, 230, 2, 2, 2803, 2804, 5, 528, 265, 2, 2804, 2805, 7, 595, 2, 2, 2805, 2807, 3, 2, 2, 2, 2806, 2803, 3, 2, 2, 2, 2806, 2807, 3, 2, 2, 2, 2807, 2808, 3, 2, 2, 2, 2808, 2809, 5, 528, 265, 2, 2809, 2810, 9, 28, 2, 2, 2810, 2811, 5, 268, 135, 2, 2811, 2832, 3, 2, 2, 2, 2812, 2816, 7, 230, 2, 2, 2813, 2814, 5, 528, 265, 2, 2814, 2815, 7, 595, 2, 2, 2815, 2817, 3, 2, 2, 2, 2816, 2813, 3, 2, 2, 2, 2816, 2817, 3, 2, 2, 2, 2817, 2818, 3, 2, 2, 2, 2818, 2819, 5, 528, 265, 2, 2819, 2820, 7, 403, 2, 2, 2820, 2821, 7, 51, 2, 2, 2821, 2832, 3, 2, 2, 2, 2822, 2826, 7, 206, 2, 2, 2823, 2824, 5, 528, 265, 2, 2824, 2825, 7, 595, 2, 2, 2825, 2827, 3, 2, 2, 2, 2826, 2823, 3, 2, 2, 2, 2826, 2827, 3, 2, 2, 2, 2827, 2828, 3, 2, 2, 2, 2828, 2832, 5, 528, 265, 2, 2829, 2830, 7, 206, 2, 2, 2830, 2832, 7, 368, 2, 2, 2831, 2802, 3, 2, 2, 2, 2831, 2812, 3, 2, 2, 2, 2831, 2822, 3, 2, 2, 2, 2831, 2829, 3, 2, 2, 2, 2832, 191, 3, 2, 2, 2, 2833, 2834, 7, 405, 2, 2, 2834, 2835, 5, 194, 98, 2, 2835, 193, 3, 2, 2, 2, 2836, 2837, 5, 528, 265, 2, 2837, 2838, 5, 494, 248, 2, 2838, 2845, 3, 2, 2, 2, 2839, 2840, 5, 44, 23, 2, 2840, 2841, 9, 19, 2, 2, 2841, 2842, 7, 438, 2, 2, 2842, 2843, 5, 694, 348, 2, 2843, 2845, 3, 2, 2, 2, 2844, 2836, 3, 2, 2, 2, 2844, 2839, 3, 2, 2, 2, 2845, 195, 3, 2, 2, 2, 2846, 2847, 7, 254, 2, 2, 2847, 2848, 5, 528, 265, 2, 2848, 2849, 5, 200, 101, 2, 2849, 197, 3, 2, 2, 2, 2850, 2851, 7, 162, 2, 2, 2851, 2880, 5, 220, 111, 2, 2852, 2853, 7, 127, 2, 2, 2853, 2854, 7, 157, 2, 2, 2854, 2880, 7, 610, 2, 2, 2855, 2856, 9, 35, 2, 2, 2856, 2857, 5, 618, 310, 2, 2857, 2858, 5, 322, 162, 2, 2858, 2880, 3, 2, 2, 2, 2859, 2860, 7, 258, 2, 2, 2860, 2861, 7, 222, 2, 2, 2861, 2874, 7, 67, 2, 2, 2862, 2863, 7, 258, 2, 2, 2863, 2864, 7, 222, 2, 2, 2864, 2874, 7, 40, 2, 2, 2865, 2874, 7, 71, 2, 2, 2866, 2874, 7, 219, 2, 2, 2867, 2874, 7, 225, 2, 2, 2868, 2874, 7, 265, 2, 2, 2869, 2871, 7, 140, 2, 2, 2870, 2869, 3, 2, 2, 2, 2870, 2871, 3, 2, 2, 2, 2871, 2872, 3, 2, 2, 2, 2872, 2874, 7, 282, 2, 2, 2873, 2859, 3, 2, 2, 2, 2873, 2862, 3, 2, 2, 2, 2873, 2865, 3, 2, 2, 2, 2873, 2866, 3, 2, 2, 2, 2873, 2867, 3, 2, 2, 2, 2873, 2868, 3, 2, 2, 2, 2873, 2870, 3, 2, 2, 2, 2874, 2876, 3, 2, 2, 2, 2875, 2877, 5, 408, 205, 2, 2876, 2875, 3, 2, 2, 2, 2876, 2877, 3, 2, 2, 2, 2877, 2878, 3, 2, 2, 2, 2878, 2880, 5, 618, 310, 2, 2879, 2850, 3, 2, 2, 2, 2879, 2852, 3, 2, 2, 2, 2879, 2855, 3, 2, 2, 2, 2879, 2873, 3, 2, 2, 2, 2880, 2881, 3, 2, 2, 2, 2881, 2882, 5, 492, 247, 2, 2882, 199, 3, 2, 2, 2, 2883, 2903, 5, 494, 248, 2, 2884, 2903, 5, 492, 247, 2, 2885, 2886, 7, 230, 2, 2, 2886, 2887, 7, 587, 2, 2, 2887, 2892, 5, 168, 85, 2, 2888, 2889, 7, 581, 2, 2, 2889, 2891, 5, 168, 85, 2, 2890, 2888, 3, 2, 2, 2, 2891, 2894, 3, 2, 2, 2, 2892, 2890, 3, 2, 2, 2, 2892, 2893, 3, 2, 2, 2, 2893, 2895, 3, 2, 2, 2, 2894, 2892, 3, 2, 2, 2, 2895, 2896, 7, 588, 2, 2, 2896, 2903, 3, 2, 2, 2, 2897, 2898, 7, 206, 2, 2, 2898, 2899, 7, 587, 2, 2, 2899, 2900, 5, 694, 348, 2, 2900, 2901, 7, 588, 2, 2, 2901, 2903, 3, 2, 2, 2, 2902, 2883, 3, 2, 2, 2, 2902, 2884, 3, 2, 2, 2, 2902, 2885, 3, 2, 2, 2, 2902, 2897, 3, 2, 2, 2, 2903, 201, 3, 2, 2, 2, 2904, 2905, 7, 242, 2, 2, 2905, 2909, 5, 618, 310, 2, 2906, 2910, 5, 494, 248, 2, 2907, 2910, 5, 496, 249, 2, 2908, 2910, 5, 492, 247, 2, 2909, 2906, 3, 2, 2, 2, 2909, 2907, 3, 2, 2, 2, 2909, 2908, 3, 2, 2, 2, 2910, 203, 3, 2, 2, 2, 2911, 2912, 7, 402, 2, 2, 2912, 2913, 7, 54, 2, 2, 2913, 2914, 7, 289, 2, 2, 2914, 2915, 5, 528, 265, 2, 2915, 2916, 5, 206, 104, 2, 2916, 205, 3, 2, 2, 2, 2917, 2918, 7, 100, 2, 2, 2918, 2922, 5, 544, 273, 2, 2919, 2920, 7, 152, 2, 2, 2920, 2922, 7, 100, 2, 2, 2921, 2917, 3, 2, 2, 2, 2921, 2919, 3, 2, 2, 2, 2921, 2922, 3, 2, 2, 2, 2922, 2927, 3, 2, 2, 2, 2923, 2924, 7, 278, 2, 2, 2924, 2928, 5, 544, 273, 2, 2925, 2926, 7, 152, 2, 2, 2926, 2928, 7, 278, 2, 2, 2927, 2923, 3, 2, 2, 2, 2927, 2925, 3, 2, 2, 2, 2927, 2928, 3, 2, 2, 2, 2928, 2930, 3, 2, 2, 2, 2929, 2931, 5, 444, 223, 2, 2930, 2929, 3, 2, 2, 2, 2930, 2931, 3, 2, 2, 2, 2931, 2935, 3, 2, 2, 2, 2932, 2935, 5, 492, 247, 2, 2933, 2935, 5, 494, 248, 2, 2934, 2921, 3, 2, 2, 2, 2934, 2932, 3, 2, 2, 2, 2934, 2933, 3, 2, 2, 2, 2935, 207, 3, 2, 2, 2, 2936, 2937, 7, 162, 2, 2, 2937, 2938, 5, 220, 111, 2, 2938, 2939, 5, 210, 106, 2, 2939, 209, 3, 2, 2, 2, 2940, 2954, 5, 496, 249, 2, 2941, 2942, 7, 230, 2, 2, 2942, 2943, 7, 587, 2, 2, 2943, 2948, 5, 212, 107, 2, 2944, 2945, 7, 581, 2, 2, 2945, 2947, 5, 212, 107, 2, 2946, 2944, 3, 2, 2, 2, 2947, 2950, 3, 2, 2, 2, 2948, 2946, 3, 2, 2, 2, 2948, 2949, 3, 2, 2, 2, 2949, 2951, 3, 2, 2, 2, 2950, 2948, 3, 2, 2, 2, 2951, 2952, 7, 588, 2, 2, 2952, 2954, 3, 2, 2, 2, 2953, 2940, 3, 2, 2, 2, 2953, 2941, 3, 2, 2, 2, 2954, 211, 3, 2, 2, 2, 2955, 2956, 9, 36, 2, 2, 2956, 2957, 7, 578, 2, 2, 2957, 2958, 5, 618, 310, 2, 2958, 213, 3, 2, 2, 2, 2959, 2960, 7, 438, 2, 2, 2960, 2962, 7, 138, 2, 2, 2961, 2963, 5, 408, 205, 2, 2962, 2961, 3, 2, 2, 2, 2962, 2963, 3, 2, 2, 2, 2963, 2964, 3, 2, 2, 2, 2964, 2967, 7, 401, 2, 2, 2965, 2968, 5, 44, 23, 2, 2966, 2968, 7, 438, 2, 2, 2967, 2965, 3, 2, 2, 2, 2967, 2966, 3, 2, 2, 2, 2968, 2969, 3, 2, 2, 2, 2969, 2970, 7, 228, 2, 2, 2970, 2971, 5, 528, 265, 2, 2971, 215, 3, 2, 2, 2, 2972, 2973, 7, 169, 2, 2, 2973, 2974, 7, 22, 2, 2, 2974, 2979, 5, 44, 23, 2, 2975, 2976, 7, 581, 2, 2, 2976, 2978, 5, 44, 23, 2, 2977, 2975, 3, 2, 2, 2, 2978, 2981, 3, 2, 2, 2, 2979, 2977, 3, 2, 2, 2, 2979, 2980, 3, 2, 2, 2, 2980, 2983, 3, 2, 2, 2, 2981, 2979, 3, 2, 2, 2, 2982, 2984, 5, 504, 253, 2, 2983, 2982, 3, 2, 2, 2, 2983, 2984, 3, 2, 2, 2, 2984, 217, 3, 2, 2, 2, 2985, 2987, 7, 162, 2, 2, 2986, 2988, 5, 408, 205, 2, 2987, 2986, 3, 2, 2, 2, 2987, 2988, 3, 2, 2, 2, 2988, 2989, 3, 2, 2, 2, 2989, 2994, 5, 220, 111, 2, 2990, 2991, 7, 581, 2, 2, 2991, 2993, 5, 220, 111, 2, 2992, 2990, 3, 2, 2, 2, 2993, 2996, 3, 2, 2, 2, 2994, 2992, 3, 2, 2, 2, 2994, 2995, 3, 2, 2, 2, 2995, 2998, 3, 2, 2, 2, 2996, 2994, 3, 2, 2, 2, 2997, 2999, 5, 504, 253, 2, 2998, 2997, 3, 2, 2, 2, 2998, 2999, 3, 2, 2, 2, 2999, 219, 3, 2, 2, 2, 3000, 3001, 5, 254, 128, 2, 3001, 3004, 7, 587, 2, 2, 3002, 3005, 5, 548, 275, 2, 3003, 3005, 7, 316, 2, 2, 3004, 3002, 3, 2, 2, 2, 3004, 3003, 3, 2, 2, 2, 3005, 3006, 3, 2, 2, 2, 3006, 3009, 7, 581, 2, 2, 3007, 3010, 5, 548, 275, 2, 3008, 3010, 7, 316, 2, 2, 3009, 3007, 3, 2, 2, 2, 3009, 3008, 3, 2, 2, 2, 3010, 3011, 3, 2, 2, 2, 3011, 3012, 7, 588, 2, 2, 3012, 221, 3, 2, 2, 2, 3013, 3014, 7, 383, 2, 2, 3014, 3016, 5, 528, 265, 2, 3015, 3013, 3, 2, 2, 2, 3015, 3016, 3, 2, 2, 2, 3016, 3026, 3, 2, 2, 2, 3017, 3018, 7, 380, 2, 2, 3018, 3019, 7, 587, 2, 2, 3019, 3020, 5, 560, 281, 2, 3020, 3021, 7, 588, 2, 2, 3021, 3027, 3, 2, 2, 2, 3022, 3024, 7, 416, 2, 2, 3023, 3022, 3, 2, 2, 2, 3023, 3024, 3, 2, 2, 2, 3024, 3025, 3, 2, 2, 2, 3025, 3027, 7, 417, 2, 2, 3026, 3017, 3, 2, 2, 2, 3026, 3023, 3, 2, 2, 2, 3027, 223, 3, 2, 2, 2, 3028, 3029, 7, 421, 2, 2, 3029, 3031, 7, 204, 2, 2, 3030, 3028, 3, 2, 2, 2, 3030, 3031, 3, 2, 2, 2, 3031, 3032, 3, 2, 2, 2, 3032, 3033, 7, 261, 2, 2, 3033, 3034, 7, 401, 2, 2, 3034, 3035, 5, 548, 275, 2, 3035, 3036, 7, 126, 2, 2, 3036, 3037, 5, 528, 265, 2, 3037, 3038, 7, 587, 2, 2, 3038, 3039, 7, 403, 2, 2, 3039, 3040, 7, 237, 2, 2, 3040, 3041, 7, 444, 2, 2, 3041, 3042, 7, 94, 2, 2, 3042, 3043, 5, 320, 161, 2, 3043, 3044, 7, 581, 2, 2, 3044, 3045, 7, 433, 2, 2, 3045, 3046, 7, 237, 2, 2, 3046, 3047, 7, 444, 2, 2, 3047, 3048, 7, 94, 2, 2, 3048, 3049, 5, 320, 161, 2, 3049, 3050, 7, 588, 2, 2, 3050, 225, 3, 2, 2, 2, 3051, 3052, 7, 5, 2, 2, 3052, 3053, 7, 142, 2, 2, 3053, 3054, 5, 528, 265, 2, 3054, 3055, 7, 265, 2, 2, 3055, 3056, 9, 37, 2, 2, 3056, 3057, 7, 100, 2, 2, 3057, 3058, 5, 618, 310, 2, 3058, 227, 3, 2, 2, 2, 3059, 3060, 9, 29, 2, 2, 3060, 3071, 5, 528, 265, 2, 3061, 3063, 7, 444, 2, 2, 3062, 3061, 3, 2, 2, 2, 3062, 3063, 3, 2, 2, 2, 3063, 3064, 3, 2, 2, 2, 3064, 3068, 5, 230, 116, 2, 3065, 3067, 5, 230, 116, 2, 3066, 3065, 3, 2, 2, 2, 3067, 3070, 3, 2, 2, 2, 3068, 3066, 3, 2, 2, 2, 3068, 3069, 3, 2, 2, 2, 3069, 3072, 3, 2, 2, 2, 3070, 3068, 3, 2, 2, 2, 3071, 3062, 3, 2, 2, 2, 3071, 3072, 3, 2, 2, 2, 3072, 229, 3, 2, 2, 2, 3073, 3077, 5, 234, 118, 2, 3074, 3077, 5, 236, 119, 2, 3075, 3077, 5, 238, 120, 2, 3076, 3073, 3, 2, 2, 2, 3076, 3074, 3, 2, 2, 2, 3076, 3075, 3, 2, 2, 2, 3077, 231, 3, 2, 2, 2, 3078, 3081, 5, 234, 118, 2, 3079, 3081, 5, 236, 119, 2, 3080, 3078, 3, 2, 2, 2, 3080, 3079, 3, 2, 2, 2, 3081, 233, 3, 2, 2, 2, 3082, 3104, 7, 536, 2, 2, 3083, 3104, 7, 506, 2, 2, 3084, 3104, 7, 456, 2, 2, 3085, 3104, 7, 501, 2, 2, 3086, 3104, 7, 457, 2, 2, 3087, 3104, 7, 502, 2, 2, 3088, 3104, 7, 115, 2, 2, 3089, 3104, 7, 503, 2, 2, 3090, 3104, 7, 487, 2, 2, 3091, 3104, 7, 504, 2, 2, 3092, 3094, 7, 77, 2, 2, 3093, 3092, 3, 2, 2, 2, 3093, 3094, 3, 2, 2, 2, 3094, 3095, 3, 2, 2, 2, 3095, 3098, 7, 176, 2, 2, 3096, 3099, 7, 615, 2, 2, 3097, 3099, 7, 417, 2, 2, 3098, 3096, 3, 2, 2, 2, 3098, 3097, 3, 2, 2, 2, 3099, 3104, 3, 2, 2, 2, 3100, 3101, 7, 276, 2, 2, 3101, 3102, 7, 273, 2, 2, 3102, 3104, 7, 615, 2, 2, 3103, 3082, 3, 2, 2, 2, 3103, 3083, 3, 2, 2, 2, 3103, 3084, 3, 2, 2, 2, 3103, 3085, 3, 2, 2, 2, 3103, 3086, 3, 2, 2, 2, 3103, 3087, 3, 2, 2, 2, 3103, 3088, 3, 2, 2, 2, 3103, 3089, 3, 2, 2, 2, 3103, 3090, 3, 2, 2, 2, 3103, 3091, 3, 2, 2, 2, 3103, 3093, 3, 2, 2, 2, 3103, 3100, 3, 2, 2, 2, 3104, 235, 3, 2, 2, 2, 3105, 3113, 7, 518, 2, 2, 3106, 3113, 7, 505, 2, 2, 3107, 3113, 7, 448, 2, 2, 3108, 3113, 7, 500, 2, 2, 3109, 3110, 7, 42, 2, 2, 3110, 3111, 7, 413, 2, 2, 3111, 3113, 5, 336, 169, 2, 3112, 3105, 3, 2, 2, 2, 3112, 3106, 3, 2, 2, 2, 3112, 3107, 3, 2, 2, 2, 3112, 3108, 3, 2, 2, 2, 3112, 3109, 3, 2, 2, 2, 3113, 237, 3, 2, 2, 2, 3114, 3115, 7, 251, 2, 2, 3115, 3127, 5, 560, 281, 2, 3116, 3117, 7, 407, 2, 2, 3117, 3124, 7, 211, 2, 2, 3118, 3119, 7, 407, 2, 2, 3119, 3124, 7, 405, 2, 2, 3120, 3124, 7, 211, 2, 2, 3121, 3124, 7, 8, 2, 2, 3122, 3124, 7, 438, 2, 2, 3123, 3116, 3, 2, 2, 2, 3123, 3118, 3, 2, 2, 2, 3123, 3120, 3, 2, 2, 2, 3123, 3121, 3, 2, 2, 2, 3123, 3122, 3, 2, 2, 2, 3124, 3125, 3, 2, 2, 2, 3125, 3127, 5, 694, 348, 2, 3126, 3114, 3, 2, 2, 2, 3126, 3123, 3, 2, 2, 2, 3127, 239, 3, 2, 2, 2, 3128, 3129, 7, 405, 2, 2, 3129, 3138, 5, 528, 265, 2, 3130, 3132, 7, 444, 2, 2, 3131, 3130, 3, 2, 2, 2, 3131, 3132, 3, 2, 2, 2, 3132, 3134, 3, 2, 2, 2, 3133, 3135, 5, 242, 122, 2, 3134, 3133, 3, 2, 2, 2, 3135, 3136, 3, 2, 2, 2, 3136, 3134, 3, 2, 2, 2, 3136, 3137, 3, 2, 2, 2, 3137, 3139, 3, 2, 2, 2, 3138, 3131, 3, 2, 2, 2, 3138, 3139, 3, 2, 2, 2, 3139, 241, 3, 2, 2, 2, 3140, 3143, 5, 234, 118, 2, 3141, 3143, 5, 238, 120, 2, 3142, 3140, 3, 2, 2, 2, 3142, 3141, 3, 2, 2, 2, 3143, 243, 3, 2, 2, 2, 3144, 3145, 7, 254, 2, 2, 3145, 3148, 5, 528, 265, 2, 3146, 3147, 7, 170, 2, 2, 3147, 3149, 5, 44, 23, 2, 3148, 3146, 3, 2, 2, 2, 3148, 3149, 3, 2, 2, 2, 3149, 3150, 3, 2, 2, 2, 3150, 3151, 7, 134, 2, 2, 3151, 3164, 7, 615, 2, 2, 3152, 3153, 7, 444, 2, 2, 3153, 3154, 7, 587, 2, 2, 3154, 3159, 5, 168, 85, 2, 3155, 3156, 7, 581, 2, 2, 3156, 3158, 5, 168, 85, 2, 3157, 3155, 3, 2, 2, 2, 3158, 3161, 3, 2, 2, 2, 3159, 3157, 3, 2, 2, 2, 3159, 3160, 3, 2, 2, 2, 3160, 3162, 3, 2, 2, 2, 3161, 3159, 3, 2, 2, 2, 3162, 3163, 7, 588, 2, 2, 3163, 3165, 3, 2, 2, 2, 3164, 3152, 3, 2, 2, 2, 3164, 3165, 3, 2, 2, 2, 3165, 245, 3, 2, 2, 2, 3166, 3168, 7, 242, 2, 2, 3167, 3169, 5, 410, 206, 2, 3168, 3167, 3, 2, 2, 2, 3168, 3169, 3, 2, 2, 2, 3169, 3170, 3, 2, 2, 2, 3170, 3175, 5, 618, 310, 2, 3171, 3172, 7, 587, 2, 2, 3172, 3173, 5, 694, 348, 2, 3173, 3174, 7, 588, 2, 2, 3174, 3176, 3, 2, 2, 2, 3175, 3171, 3, 2, 2, 2, 3175, 3176, 3, 2, 2, 2, 3176, 3177, 3, 2, 2, 2, 3177, 3178, 7, 419, 2, 2, 3178, 3179, 5, 528, 265, 2, 3179, 3180, 7, 581, 2, 2, 3180, 3181, 5, 694, 348, 2, 3181, 3182, 7, 403, 2, 2, 3182, 3183, 5, 618, 310, 2, 3183, 247, 3, 2, 2, 2, 3184, 3185, 7, 402, 2, 2, 3185, 3186, 7, 54, 2, 2, 3186, 3187, 7, 289, 2, 2, 3187, 3192, 5, 528, 265, 2, 3188, 3189, 7, 100, 2, 2, 3189, 3193, 5, 544, 273, 2, 3190, 3191, 7, 152, 2, 2, 3191, 3193, 7, 100, 2, 2, 3192, 3188, 3, 2, 2, 2, 3192, 3190, 3, 2, 2, 2, 3192, 3193, 3, 2, 2, 2, 3193, 3198, 3, 2, 2, 2, 3194, 3195, 7, 278, 2, 2, 3195, 3199, 5, 544, 273, 2, 3196, 3197, 7, 152, 2, 2, 3197, 3199, 7, 278, 2, 2, 3198, 3194, 3, 2, 2, 2, 3198, 3196, 3, 2, 2, 2, 3198, 3199, 3, 2, 2, 2, 3199, 3212, 3, 2, 2, 2, 3200, 3201, 7, 164, 2, 2, 3201, 3202, 7, 587, 2, 2, 3202, 3207, 5, 250, 126, 2, 3203, 3204, 7, 581, 2, 2, 3204, 3206, 5, 250, 126, 2, 3205, 3203, 3, 2, 2, 2, 3206, 3209, 3, 2, 2, 2, 3207, 3205, 3, 2, 2, 2, 3207, 3208, 3, 2, 2, 2, 3208, 3210, 3, 2, 2, 2, 3209, 3207, 3, 2, 2, 2, 3210, 3211, 7, 588, 2, 2, 3211, 3213, 3, 2, 2, 2, 3212, 3200, 3, 2, 2, 2, 3212, 3213, 3, 2, 2, 2, 3213, 249, 3, 2, 2, 2, 3214, 3215, 5, 528, 265, 2, 3215, 3216, 7, 615, 2, 2, 3216, 251, 3, 2, 2, 2, 3217, 3218, 7, 162, 2, 2, 3218, 3219, 5, 254, 128, 2, 3219, 3220, 7, 587, 2, 2, 3220, 3225, 5, 256, 129, 2, 3221, 3222, 7, 581, 2, 2, 3222, 3224, 5, 256, 129, 2, 3223, 3221, 3, 2, 2, 2, 3224, 3227, 3, 2, 2, 2, 3225, 3223, 3, 2, 2, 2, 3225, 3226, 3, 2, 2, 2, 3226, 3228, 3, 2, 2, 2, 3227, 3225, 3, 2, 2, 2, 3228, 3229, 7, 588, 2, 2, 3229, 253, 3, 2, 2, 2, 3230, 3231, 5, 528, 265, 2, 3231, 3232, 7, 595, 2, 2, 3232, 3234, 3, 2, 2, 2, 3233, 3230, 3, 2, 2, 2, 3233, 3234, 3, 2, 2, 2, 3234, 3235, 3, 2, 2, 2, 3235, 3236, 5, 466, 234, 2, 3236, 255, 3, 2, 2, 2, 3237, 3238, 9, 18, 2, 2, 3238, 3239, 7, 578, 2, 2, 3239, 3255, 5, 618, 310, 2, 3240, 3241, 7, 208, 2, 2, 3241, 3242, 7, 578, 2, 2, 3242, 3255, 5, 618, 310, 2, 3243, 3244, 7, 357, 2, 2, 3244, 3245, 7, 578, 2, 2, 3245, 3255, 5, 618, 310, 2, 3246, 3247, 9, 38, 2, 2, 3247, 3248, 7, 578, 2, 2, 3248, 3255, 5, 548, 275, 2, 3249, 3250, 9, 39, 2, 2, 3250, 3251, 7, 578, 2, 2, 3251, 3255, 5, 566, 284, 2, 3252, 3255, 7, 472, 2, 2, 3253, 3255, 7, 489, 2, 2, 3254, 3237, 3, 2, 2, 2, 3254, 3240, 3, 2, 2, 2, 3254, 3243, 3, 2, 2, 2, 3254, 3246, 3, 2, 2, 2, 3254, 3249, 3, 2, 2, 2, 3254, 3252, 3, 2, 2, 2, 3254, 3253, 3, 2, 2, 2, 3255, 257, 3, 2, 2, 2, 3256, 3257, 7, 421, 2, 2, 3257, 3259, 7, 204, 2, 2, 3258, 3256, 3, 2, 2, 2, 3258, 3259, 3, 2, 2, 2, 3259, 3260, 3, 2, 2, 2, 3260, 3261, 7, 10, 2, 2, 3261, 3263, 5, 618, 310, 2, 3262, 3264, 5, 322, 162, 2, 3263, 3262, 3, 2, 2, 2, 3263, 3264, 3, 2, 2, 2, 3264, 3265, 3, 2, 2, 2, 3265, 3271, 7, 587, 2, 2, 3266, 3267, 7, 446, 2, 2, 3267, 3268, 7, 578, 2, 2, 3268, 3269, 5, 548, 275, 2, 3269, 3270, 7, 581, 2, 2, 3270, 3272, 3, 2, 2, 2, 3271, 3266, 3, 2, 2, 2, 3271, 3272, 3, 2, 2, 2, 3272, 3273, 3, 2, 2, 2, 3273, 3274, 7, 526, 2, 2, 3274, 3275, 7, 578, 2, 2, 3275, 3276, 5, 618, 310, 2, 3276, 3277, 7, 581, 2, 2, 3277, 3278, 7, 531, 2, 2, 3278, 3279, 7, 578, 2, 2, 3279, 3284, 5, 548, 275, 2, 3280, 3281, 7, 581, 2, 2, 3281, 3283, 5, 260, 131, 2, 3282, 3280, 3, 2, 2, 2, 3283, 3286, 3, 2, 2, 2, 3284, 3282, 3, 2, 2, 2, 3284, 3285, 3, 2, 2, 2, 3285, 3287, 3, 2, 2, 2, 3286, 3284, 3, 2, 2, 2, 3287, 3288, 7, 588, 2, 2, 3288, 259, 3, 2, 2, 2, 3289, 3290, 7, 530, 2, 2, 3290, 3291, 7, 578, 2, 2, 3291, 3341, 7, 610, 2, 2, 3292, 3293, 7, 463, 2, 2, 3293, 3294, 7, 578, 2, 2, 3294, 3341, 5, 618, 310, 2, 3295, 3341, 7, 464, 2, 2, 3296, 3297, 7, 465, 2, 2, 3297, 3298, 7, 578, 2, 2, 3298, 3341, 9, 40, 2, 2, 3299, 3300, 7, 452, 2, 2, 3300, 3301, 7, 578, 2, 2, 3301, 3341, 5, 618, 310, 2, 3302, 3303, 7, 524, 2, 2, 3303, 3304, 7, 578, 2, 2, 3304, 3341, 5, 618, 310, 2, 3305, 3306, 7, 458, 2, 2, 3306, 3307, 7, 578, 2, 2, 3307, 3341, 5, 618, 310, 2, 3308, 3309, 7, 477, 2, 2, 3309, 3310, 7, 578, 2, 2, 3310, 3341, 5, 560, 281, 2, 3311, 3312, 7, 496, 2, 2, 3312, 3313, 7, 578, 2, 2, 3313, 3341, 5, 618, 310, 2, 3314, 3315, 7, 494, 2, 2, 3315, 3316, 7, 578, 2, 2, 3316, 3341, 5, 618, 310, 2, 3317, 3318, 7, 498, 2, 2, 3318, 3319, 7, 578, 2, 2, 3319, 3341, 5, 548, 275, 2, 3320, 3321, 7, 497, 2, 2, 3321, 3322, 7, 578, 2, 2, 3322, 3341, 7, 610, 2, 2, 3323, 3324, 7, 490, 2, 2, 3324, 3325, 7, 578, 2, 2, 3325, 3341, 5, 618, 310, 2, 3326, 3341, 7, 491, 2, 2, 3327, 3328, 7, 492, 2, 2, 3328, 3329, 7, 578, 2, 2, 3329, 3341, 9, 40, 2, 2, 3330, 3331, 7, 493, 2, 2, 3331, 3332, 7, 578, 2, 2, 3332, 3341, 5, 560, 281, 2, 3333, 3334, 7, 529, 2, 2, 3334, 3335, 7, 578, 2, 2, 3335, 3341, 5, 566, 284, 2, 3336, 3337, 7, 171, 2, 2, 3337, 3338, 7, 578, 2, 2, 3338, 3341, 9, 27, 2, 2, 3339, 3341, 7, 474, 2, 2, 3340, 3289, 3, 2, 2, 2, 3340, 3292, 3, 2, 2, 2, 3340, 3295, 3, 2, 2, 2, 3340, 3296, 3, 2, 2, 2, 3340, 3299, 3, 2, 2, 2, 3340, 3302, 3, 2, 2, 2, 3340, 3305, 3, 2, 2, 2, 3340, 3308, 3, 2, 2, 2, 3340, 3311, 3, 2, 2, 2, 3340, 3314, 3, 2, 2, 2, 3340, 3317, 3, 2, 2, 2, 3340, 3320, 3, 2, 2, 2, 3340, 3323, 3, 2, 2, 2, 3340, 3326, 3, 2, 2, 2, 3340, 3327, 3, 2, 2, 2, 3340, 3330, 3, 2, 2, 2, 3340, 3333, 3, 2, 2, 2, 3340, 3336, 3, 2, 2, 2, 3340, 3339, 3, 2, 2, 2, 3341, 261, 3, 2, 2, 2, 3342, 3343, 7, 230, 2, 2, 3343, 3344, 5, 264, 133, 2, 3344, 263, 3, 2, 2, 2, 3345, 3348, 7, 43, 2, 2, 3346, 3349, 7, 368, 2, 2, 3347, 3349, 5, 474, 238, 2, 3348, 3346, 3, 2, 2, 2, 3348, 3347, 3, 2, 2, 2, 3349, 3350, 3, 2, 2, 2, 3350, 3383, 9, 25, 2, 2, 3351, 3352, 7, 260, 2, 2, 3352, 3357, 5, 22, 12, 2, 3353, 3354, 7, 581, 2, 2, 3354, 3356, 5, 22, 12, 2, 3355, 3353, 3, 2, 2, 2, 3356, 3359, 3, 2, 2, 2, 3357, 3355, 3, 2, 2, 2, 3357, 3358, 3, 2, 2, 2, 3358, 3383, 3, 2, 2, 2, 3359, 3357, 3, 2, 2, 2, 3360, 3361, 7, 260, 2, 2, 3361, 3362, 7, 236, 2, 2, 3362, 3383, 7, 615, 2, 2, 3363, 3364, 7, 229, 2, 2, 3364, 3365, 7, 30, 2, 2, 3365, 3366, 7, 374, 2, 2, 3366, 3367, 7, 260, 2, 2, 3367, 3372, 5, 22, 12, 2, 3368, 3369, 7, 581, 2, 2, 3369, 3371, 5, 22, 12, 2, 3370, 3368, 3, 2, 2, 2, 3371, 3374, 3, 2, 2, 2, 3372, 3370, 3, 2, 2, 2, 3372, 3373, 3, 2, 2, 2, 3373, 3383, 3, 2, 2, 2, 3374, 3372, 3, 2, 2, 2, 3375, 3377, 9, 41, 2, 2, 3376, 3375, 3, 2, 2, 2, 3376, 3377, 3, 2, 2, 2, 3377, 3378, 3, 2, 2, 2, 3378, 3383, 5, 266, 134, 2, 3379, 3380, 7, 291, 2, 2, 3380, 3381, 7, 163, 2, 2, 3381, 3383, 9, 42, 2, 2, 3382, 3345, 3, 2, 2, 2, 3382, 3351, 3, 2, 2, 2, 3382, 3360, 3, 2, 2, 2, 3382, 3363, 3, 2, 2, 2, 3382, 3376, 3, 2, 2, 2, 3382, 3379, 3, 2, 2, 2, 3383, 265, 3, 2, 2, 2, 3384, 3385, 7, 229, 2, 2, 3385, 3389, 7, 345, 2, 2, 3386, 3390, 7, 615, 2, 2, 3387, 3390, 5, 528, 265, 2, 3388, 3390, 7, 391, 2, 2, 3389, 3386, 3, 2, 2, 2, 3389, 3387, 3, 2, 2, 2, 3389, 3388, 3, 2, 2, 2, 3390, 3414, 3, 2, 2, 2, 3391, 3392, 7, 328, 2, 2, 3392, 3397, 7, 294, 2, 2, 3393, 3398, 7, 615, 2, 2, 3394, 3398, 5, 338, 170, 2, 3395, 3398, 7, 133, 2, 2, 3396, 3398, 7, 391, 2, 2, 3397, 3393, 3, 2, 2, 2, 3397, 3394, 3, 2, 2, 2, 3397, 3395, 3, 2, 2, 2, 3397, 3396, 3, 2, 2, 2, 3398, 3414, 3, 2, 2, 2, 3399, 3400, 5, 528, 265, 2, 3400, 3401, 7, 595, 2, 2, 3401, 3403, 3, 2, 2, 2, 3402, 3399, 3, 2, 2, 2, 3402, 3403, 3, 2, 2, 2, 3403, 3404, 3, 2, 2, 2, 3404, 3405, 5, 528, 265, 2, 3405, 3406, 9, 28, 2, 2, 3406, 3407, 5, 268, 135, 2, 3407, 3414, 3, 2, 2, 2, 3408, 3411, 7, 211, 2, 2, 3409, 3412, 5, 528, 265, 2, 3410, 3412, 7, 316, 2, 2, 3411, 3409, 3, 2, 2, 2, 3411, 3410, 3, 2, 2, 2, 3412, 3414, 3, 2, 2, 2, 3413, 3384, 3, 2, 2, 2, 3413, 3391, 3, 2, 2, 2, 3413, 3402, 3, 2, 2, 2, 3413, 3408, 3, 2, 2, 2, 3414, 267, 3, 2, 2, 2, 3415, 3420, 5, 560, 281, 2, 3416, 3417, 7, 581, 2, 2, 3417, 3419, 5, 560, 281, 2, 3418, 3416, 3, 2, 2, 2, 3419, 3422, 3, 2, 2, 2, 3420, 3418, 3, 2, 2, 2, 3420, 3421, 3, 2, 2, 2, 3421, 3425, 3, 2, 2, 2, 3422, 3420, 3, 2, 2, 2, 3423, 3425, 7, 391, 2, 2, 3424, 3415, 3, 2, 2, 2, 3424, 3423, 3, 2, 2, 2, 3425, 269, 3, 2, 2, 2, 3426, 3427, 7, 421, 2, 2, 3427, 3429, 7, 204, 2, 2, 3428, 3426, 3, 2, 2, 2, 3428, 3429, 3, 2, 2, 2, 3429, 3430, 3, 2, 2, 2, 3430, 3431, 7, 217, 2, 2, 3431, 3432, 5, 528, 265, 2, 3432, 3433, 7, 374, 2, 2, 3433, 3434, 7, 419, 2, 2, 3434, 3435, 9, 43, 2, 2, 3435, 3436, 7, 433, 2, 2, 3436, 3439, 5, 618, 310, 2, 3437, 3438, 7, 442, 2, 2, 3438, 3440, 5, 560, 281, 2, 3439, 3437, 3, 2, 2, 2, 3439, 3440, 3, 2, 2, 2, 3440, 3441, 3, 2, 2, 2, 3441, 3443, 7, 395, 2, 2, 3442, 3444, 9, 44, 2, 2, 3443, 3442, 3, 2, 2, 2, 3443, 3444, 3, 2, 2, 2, 3444, 3462, 3, 2, 2, 2, 3445, 3463, 7, 153, 2, 2, 3446, 3463, 5, 272, 137, 2, 3447, 3453, 7, 587, 2, 2, 3448, 3449, 5, 272, 137, 2, 3449, 3450, 7, 580, 2, 2, 3450, 3452, 3, 2, 2, 2, 3451, 3448, 3, 2, 2, 2, 3452, 3455, 3, 2, 2, 2, 3453, 3451, 3, 2, 2, 2, 3453, 3454, 3, 2, 2, 2, 3454, 3456, 3, 2, 2, 2, 3455, 3453, 3, 2, 2, 2, 3456, 3458, 5, 272, 137, 2, 3457, 3459, 7, 580, 2, 2, 3458, 3457, 3, 2, 2, 2, 3458, 3459, 3, 2, 2, 2, 3459, 3460, 3, 2, 2, 2, 3460, 3461, 7, 588, 2, 2, 3461, 3463, 3, 2, 2, 2, 3462, 3445, 3, 2, 2, 2, 3462, 3446, 3, 2, 2, 2, 3462, 3447, 3, 2, 2, 2, 3463, 271, 3, 2, 2, 2, 3464, 3470, 5, 624, 313, 2, 3465, 3470, 5, 674, 338, 2, 3466, 3470, 5, 686, 344, 2, 3467, 3470, 5, 684, 343, 2, 3468, 3470, 5, 690, 346, 2, 3469, 3464, 3, 2, 2, 2, 3469, 3465, 3, 2, 2, 2, 3469, 3466, 3, 2, 2, 2, 3469, 3467, 3, 2, 2, 2, 3469, 3468, 3, 2, 2, 2, 3470, 273, 3, 2, 2, 2, 3471, 3473, 7, 383, 2, 2, 3472, 3471, 3, 2, 2, 2, 3472, 3473, 3, 2, 2, 2, 3473, 3474, 3, 2, 2, 2, 3474, 3475, 7, 262, 2, 2, 3475, 3480, 5, 528, 265, 2, 3476, 3481, 7, 20, 2, 2, 3477, 3478, 7, 121, 2, 2, 3478, 3481, 7, 158, 2, 2, 3479, 3481, 7, 9, 2, 2, 3480, 3476, 3, 2, 2, 2, 3480, 3477, 3, 2, 2, 2, 3480, 3479, 3, 2, 2, 2, 3481, 3497, 3, 2, 2, 2, 3482, 3486, 7, 120, 2, 2, 3483, 3486, 7, 62, 2, 2, 3484, 3486, 7, 263, 2, 2, 3485, 3482, 3, 2, 2, 2, 3485, 3483, 3, 2, 2, 2, 3485, 3484, 3, 2, 2, 2, 3486, 3493, 3, 2, 2, 2, 3487, 3490, 7, 274, 2, 2, 3488, 3489, 7, 158, 2, 2, 3489, 3491, 5, 694, 348, 2, 3490, 3488, 3, 2, 2, 2, 3490, 3491, 3, 2, 2, 2, 3491, 3493, 3, 2, 2, 2, 3492, 3485, 3, 2, 2, 2, 3492, 3487, 3, 2, 2, 2, 3493, 3495, 3, 2, 2, 2, 3494, 3496, 7, 421, 2, 2, 3495, 3494, 3, 2, 2, 2, 3495, 3496, 3, 2, 2, 2, 3496, 3498, 3, 2, 2, 2, 3497, 3492, 3, 2, 2, 2, 3498, 3499, 3, 2, 2, 2, 3499, 3497, 3, 2, 2, 2, 3499, 3500, 3, 2, 2, 2, 3500, 3501, 3, 2, 2, 2, 3501, 3502, 7, 419, 2, 2, 3502, 3505, 5, 618, 310, 2, 3503, 3504, 7, 403, 2, 2, 3504, 3506, 5, 618, 310, 2, 3505, 3503, 3, 2, 2, 2, 3505, 3506, 3, 2, 2, 2, 3506, 3508, 3, 2, 2, 2, 3507, 3509, 5, 100, 51, 2, 3508, 3507, 3, 2, 2, 2, 3508, 3509, 3, 2, 2, 2, 3509, 3511, 3, 2, 2, 2, 3510, 3512, 5, 102, 52, 2, 3511, 3510, 3, 2, 2, 2, 3511, 3512, 3, 2, 2, 2, 3512, 3518, 3, 2, 2, 2, 3513, 3514, 7, 197, 2, 2, 3514, 3516, 5, 276, 139, 2, 3515, 3517, 5, 276, 139, 2, 3516, 3515, 3, 2, 2, 2, 3516, 3517, 3, 2, 2, 2, 3517, 3519, 3, 2, 2, 2, 3518, 3513, 3, 2, 2, 2, 3518, 3519, 3, 2, 2, 2, 3519, 3525, 3, 2, 2, 2, 3520, 3522, 7, 401, 2, 2, 3521, 3523, 7, 74, 2, 2, 3522, 3521, 3, 2, 2, 2, 3522, 3523, 3, 2, 2, 2, 3523, 3524, 3, 2, 2, 2, 3524, 3526, 9, 45, 2, 2, 3525, 3520, 3, 2, 2, 2, 3525, 3526, 3, 2, 2, 2, 3526, 3528, 3, 2, 2, 2, 3527, 3529, 5, 278, 140, 2, 3528, 3527, 3, 2, 2, 2, 3528, 3529, 3, 2, 2, 2, 3529, 3530, 3, 2, 2, 2, 3530, 3531, 7, 84, 2, 2, 3531, 3532, 9, 18, 2, 2, 3532, 3533, 5, 582, 292, 2, 3533, 275, 3, 2, 2, 2, 3534, 3535, 9, 46, 2, 2, 3535, 3537, 7, 431, 2, 2, 3536, 3538, 7, 374, 2, 2, 3537, 3536, 3, 2, 2, 2, 3537, 3538, 3, 2, 2, 2, 3538, 3539, 3, 2, 2, 2, 3539, 3540, 5, 528, 265, 2, 3540, 277, 3, 2, 2, 2, 3541, 3542, 7, 441, 2, 2, 3542, 3543, 7, 587, 2, 2, 3543, 3544, 5, 560, 281, 2, 3544, 3545, 7, 588, 2, 2, 3545, 279, 3, 2, 2, 2, 3546, 3552, 7, 404, 2, 2, 3547, 3549, 7, 210, 2, 2, 3548, 3550, 5, 116, 59, 2, 3549, 3548, 3, 2, 2, 2, 3549, 3550, 3, 2, 2, 2, 3550, 3552, 3, 2, 2, 2, 3551, 3546, 3, 2, 2, 2, 3551, 3547, 3, 2, 2, 2, 3552, 3555, 3, 2, 2, 2, 3553, 3556, 5, 288, 145, 2, 3554, 3556, 5, 284, 143, 2, 3555, 3553, 3, 2, 2, 2, 3555, 3554, 3, 2, 2, 2, 3556, 3557, 3, 2, 2, 2, 3557, 3558, 7, 419, 2, 2, 3558, 3559, 5, 282, 142, 2, 3559, 3560, 9, 47, 2, 2, 3560, 3565, 5, 298, 150, 2, 3561, 3562, 7, 444, 2, 2, 3562, 3563, 7, 404, 2, 2, 3563, 3566, 7, 163, 2, 2, 3564, 3566, 5, 504, 253, 2, 3565, 3561, 3, 2, 2, 2, 3565, 3564, 3, 2, 2, 2, 3565, 3566, 3, 2, 2, 2, 3566, 3569, 3, 2, 2, 2, 3567, 3569, 5, 292, 147, 2, 3568, 3551, 3, 2, 2, 2, 3568, 3567, 3, 2, 2, 2, 3569, 281, 3, 2, 2, 2, 3570, 3572, 7, 431, 2, 2, 3571, 3570, 3, 2, 2, 2, 3571, 3572, 3, 2, 2, 2, 3572, 3573, 3, 2, 2, 2, 3573, 3620, 5, 474, 238, 2, 3574, 3575, 7, 225, 2, 2, 3575, 3620, 5, 474, 238, 2, 3576, 3577, 7, 55, 2, 2, 3577, 3620, 5, 474, 238, 2, 3578, 3579, 7, 71, 2, 2, 3579, 3620, 5, 474, 238, 2, 3580, 3581, 7, 402, 2, 2, 3581, 3582, 7, 54, 2, 2, 3582, 3583, 7, 289, 2, 2, 3583, 3620, 5, 474, 238, 2, 3584, 3585, 7, 402, 2, 2, 3585, 3586, 7, 228, 2, 2, 3586, 3620, 5, 474, 238, 2, 3587, 3588, 9, 48, 2, 2, 3588, 3593, 5, 320, 161, 2, 3589, 3590, 7, 581, 2, 2, 3590, 3592, 5, 320, 161, 2, 3591, 3589, 3, 2, 2, 2, 3592, 3595, 3, 2, 2, 2, 3593, 3591, 3, 2, 2, 2, 3593, 3594, 3, 2, 2, 2, 3594, 3620, 3, 2, 2, 2, 3595, 3593, 3, 2, 2, 2, 3596, 3597, 7, 127, 2, 2, 3597, 3598, 7, 157, 2, 2, 3598, 3603, 7, 610, 2, 2, 3599, 3600, 7, 581, 2, 2, 3600, 3602, 7, 610, 2, 2, 3601, 3599, 3, 2, 2, 2, 3602, 3605, 3, 2, 2, 2, 3603, 3601, 3, 2, 2, 2, 3603, 3604, 3, 2, 2, 2, 3604, 3620, 3, 2, 2, 2, 3605, 3603, 3, 2, 2, 2, 3606, 3607, 7, 126, 2, 2, 3607, 3620, 5, 474, 238, 2, 3608, 3609, 7, 219, 2, 2, 3609, 3620, 5, 474, 238, 2, 3610, 3611, 7, 254, 2, 2, 3611, 3620, 5, 474, 238, 2, 3612, 3613, 7, 265, 2, 2, 3613, 3620, 5, 474, 238, 2, 3614, 3615, 7, 368, 2, 2, 3615, 3616, 9, 49, 2, 2, 3616, 3617, 7, 407, 2, 2, 3617, 3618, 7, 219, 2, 2, 3618, 3620, 5, 474, 238, 2, 3619, 3571, 3, 2, 2, 2, 3619, 3574, 3, 2, 2, 2, 3619, 3576, 3, 2, 2, 2, 3619, 3578, 3, 2, 2, 2, 3619, 3580, 3, 2, 2, 2, 3619, 3584, 3, 2, 2, 2, 3619, 3587, 3, 2, 2, 2, 3619, 3596, 3, 2, 2, 2, 3619, 3606, 3, 2, 2, 2, 3619, 3608, 3, 2, 2, 2, 3619, 3610, 3, 2, 2, 2, 3619, 3612, 3, 2, 2, 2, 3619, 3614, 3, 2, 2, 2, 3620, 283, 3, 2, 2, 2, 3621, 3626, 5, 286, 144, 2, 3622, 3623, 7, 581, 2, 2, 3623, 3625, 5, 286, 144, 2, 3624, 3622, 3, 2, 2, 2, 3625, 3628, 3, 2, 2, 2, 3626, 3624, 3, 2, 2, 2, 3626, 3627, 3, 2, 2, 2, 3627, 285, 3, 2, 2, 2, 3628, 3626, 3, 2, 2, 2, 3629, 3630, 5, 498, 250, 2, 3630, 3631, 7, 587, 2, 2, 3631, 3632, 5, 694, 348, 2, 3632, 3633, 7, 588, 2, 2, 3633, 287, 3, 2, 2, 2, 3634, 3639, 5, 290, 146, 2, 3635, 3636, 7, 581, 2, 2, 3636, 3638, 5, 290, 146, 2, 3637, 3635, 3, 2, 2, 2, 3638, 3641, 3, 2, 2, 2, 3639, 3637, 3, 2, 2, 2, 3639, 3640, 3, 2, 2, 2, 3640, 289, 3, 2, 2, 2, 3641, 3639, 3, 2, 2, 2, 3642, 3644, 7, 368, 2, 2, 3643, 3645, 7, 184, 2, 2, 3644, 3643, 3, 2, 2, 2, 3644, 3645, 3, 2, 2, 2, 3645, 3659, 3, 2, 2, 2, 3646, 3659, 7, 454, 2, 2, 3647, 3659, 7, 384, 2, 2, 3648, 3659, 7, 62, 2, 2, 3649, 3659, 7, 84, 2, 2, 3650, 3659, 7, 120, 2, 2, 3651, 3659, 7, 274, 2, 2, 3652, 3659, 7, 425, 2, 2, 3653, 3659, 7, 427, 2, 2, 3654, 3659, 7, 255, 2, 2, 3655, 3659, 7, 262, 2, 2, 3656, 3659, 7, 263, 2, 2, 3657, 3659, 7, 541, 2, 2, 3658, 3642, 3, 2, 2, 2, 3658, 3646, 3, 2, 2, 2, 3658, 3647, 3, 2, 2, 2, 3658, 3648, 3, 2, 2, 2, 3658, 3649, 3, 2, 2, 2, 3658, 3650, 3, 2, 2, 2, 3658, 3651, 3, 2, 2, 2, 3658, 3652, 3, 2, 2, 2, 3658, 3653, 3, 2, 2, 2, 3658, 3654, 3, 2, 2, 2, 3658, 3655, 3, 2, 2, 2, 3658, 3656, 3, 2, 2, 2, 3658, 3657, 3, 2, 2, 2, 3659, 291, 3, 2, 2, 2, 3660, 3661, 7, 404, 2, 2, 3661, 3662, 5, 474, 238, 2, 3662, 3663, 7, 433, 2, 2, 3663, 3667, 5, 474, 238, 2, 3664, 3665, 7, 444, 2, 2, 3665, 3666, 7, 8, 2, 2, 3666, 3668, 7, 163, 2, 2, 3667, 3664, 3, 2, 2, 2, 3667, 3668, 3, 2, 2, 2, 3668, 3682, 3, 2, 2, 2, 3669, 3673, 7, 210, 2, 2, 3670, 3671, 7, 8, 2, 2, 3671, 3672, 7, 163, 2, 2, 3672, 3674, 7, 401, 2, 2, 3673, 3670, 3, 2, 2, 2, 3673, 3674, 3, 2, 2, 2, 3674, 3675, 3, 2, 2, 2, 3675, 3676, 5, 474, 238, 2, 3676, 3677, 7, 403, 2, 2, 3677, 3679, 5, 474, 238, 2, 3678, 3680, 5, 504, 253, 2, 3679, 3678, 3, 2, 2, 2, 3679, 3680, 3, 2, 2, 2, 3680, 3682, 3, 2, 2, 2, 3681, 3660, 3, 2, 2, 2, 3681, 3669, 3, 2, 2, 2, 3682, 293, 3, 2, 2, 2, 3683, 3684, 7, 433, 2, 2, 3684, 3688, 5, 298, 150, 2, 3685, 3686, 7, 444, 2, 2, 3686, 3687, 7, 404, 2, 2, 3687, 3689, 7, 163, 2, 2, 3688, 3685, 3, 2, 2, 2, 3688, 3689, 3, 2, 2, 2, 3689, 295, 3, 2, 2, 2, 3690, 3691, 7, 403, 2, 2, 3691, 3693, 5, 298, 150, 2, 3692, 3694, 5, 504, 253, 2, 3693, 3692, 3, 2, 2, 2, 3693, 3694, 3, 2, 2, 2, 3694, 297, 3, 2, 2, 2, 3695, 3700, 5, 300, 151, 2, 3696, 3697, 7, 581, 2, 2, 3697, 3699, 5, 300, 151, 2, 3698, 3696, 3, 2, 2, 2, 3699, 3702, 3, 2, 2, 2, 3700, 3698, 3, 2, 2, 2, 3700, 3701, 3, 2, 2, 2, 3701, 299, 3, 2, 2, 2, 3702, 3700, 3, 2, 2, 2, 3703, 3705, 7, 405, 2, 2, 3704, 3703, 3, 2, 2, 2, 3704, 3705, 3, 2, 2, 2, 3705, 3706, 3, 2, 2, 2, 3706, 3707, 5, 44, 23, 2, 3707, 301, 3, 2, 2, 2, 3708, 3709, 7, 36, 2, 2, 3709, 3710, 7, 419, 2, 2, 3710, 3711, 5, 306, 154, 2, 3711, 3714, 7, 355, 2, 2, 3712, 3715, 5, 326, 164, 2, 3713, 3715, 7, 417, 2, 2, 3714, 3712, 3, 2, 2, 2, 3714, 3713, 3, 2, 2, 2, 3715, 303, 3, 2, 2, 2, 3716, 3717, 7, 224, 2, 2, 3717, 3723, 7, 125, 2, 2, 3718, 3721, 7, 401, 2, 2, 3719, 3722, 5, 528, 265, 2, 3720, 3722, 5, 326, 164, 2, 3721, 3719, 3, 2, 2, 2, 3721, 3720, 3, 2, 2, 2, 3722, 3724, 3, 2, 2, 2, 3723, 3718, 3, 2, 2, 2, 3723, 3724, 3, 2, 2, 2, 3724, 3725, 3, 2, 2, 2, 3725, 3726, 7, 419, 2, 2, 3726, 3727, 5, 308, 155, 2, 3727, 3730, 7, 355, 2, 2, 3728, 3731, 5, 326, 164, 2, 3729, 3731, 7, 417, 2, 2, 3730, 3728, 3, 2, 2, 2, 3730, 3729, 3, 2, 2, 2, 3731, 305, 3, 2, 2, 2, 3732, 3733, 7, 5, 2, 2, 3733, 3734, 7, 142, 2, 2, 3734, 3857, 5, 528, 265, 2, 3735, 3736, 9, 50, 2, 2, 3736, 3737, 5, 618, 310, 2, 3737, 3738, 5, 322, 162, 2, 3738, 3857, 3, 2, 2, 2, 3739, 3740, 7, 379, 2, 2, 3740, 3741, 7, 587, 2, 2, 3741, 3742, 5, 548, 275, 2, 3742, 3743, 7, 374, 2, 2, 3743, 3744, 5, 548, 275, 2, 3744, 3745, 7, 588, 2, 2, 3745, 3857, 3, 2, 2, 2, 3746, 3747, 7, 347, 2, 2, 3747, 3857, 5, 528, 265, 2, 3748, 3749, 7, 382, 2, 2, 3749, 3857, 5, 618, 310, 2, 3750, 3751, 7, 383, 2, 2, 3751, 3752, 5, 528, 265, 2, 3752, 3754, 7, 419, 2, 2, 3753, 3755, 7, 71, 2, 2, 3754, 3753, 3, 2, 2, 2, 3754, 3755, 3, 2, 2, 2, 3755, 3756, 3, 2, 2, 2, 3756, 3757, 5, 618, 310, 2, 3757, 3857, 3, 2, 2, 2, 3758, 3759, 7, 46, 2, 2, 3759, 3857, 5, 618, 310, 2, 3760, 3761, 7, 55, 2, 2, 3761, 3857, 5, 528, 265, 2, 3762, 3763, 7, 71, 2, 2, 3763, 3857, 5, 618, 310, 2, 3764, 3765, 7, 86, 2, 2, 3765, 3857, 5, 528, 265, 2, 3766, 3767, 7, 80, 2, 2, 3767, 3768, 7, 262, 2, 2, 3768, 3857, 5, 528, 265, 2, 3769, 3770, 7, 402, 2, 2, 3770, 3771, 7, 54, 2, 2, 3771, 3772, 7, 289, 2, 2, 3772, 3857, 5, 528, 265, 2, 3773, 3775, 7, 402, 2, 2, 3774, 3773, 3, 2, 2, 2, 3774, 3775, 3, 2, 2, 2, 3775, 3776, 3, 2, 2, 2, 3776, 3777, 7, 431, 2, 2, 3777, 3857, 5, 618, 310, 2, 3778, 3779, 7, 113, 2, 2, 3779, 3857, 5, 618, 310, 2, 3780, 3781, 7, 127, 2, 2, 3781, 3782, 7, 157, 2, 2, 3782, 3857, 7, 610, 2, 2, 3783, 3785, 7, 140, 2, 2, 3784, 3783, 3, 2, 2, 2, 3784, 3785, 3, 2, 2, 2, 3785, 3786, 3, 2, 2, 2, 3786, 3787, 7, 282, 2, 2, 3787, 3857, 5, 618, 310, 2, 3788, 3789, 7, 162, 2, 2, 3789, 3857, 5, 220, 111, 2, 3790, 3791, 7, 162, 2, 2, 3791, 3792, 9, 51, 2, 2, 3792, 3793, 5, 618, 310, 2, 3793, 3794, 7, 439, 2, 2, 3794, 3795, 5, 528, 265, 2, 3795, 3857, 3, 2, 2, 2, 3796, 3797, 7, 178, 2, 2, 3797, 3798, 5, 528, 265, 2, 3798, 3799, 7, 419, 2, 2, 3799, 3800, 5, 618, 310, 2, 3800, 3857, 3, 2, 2, 2, 3801, 3803, 7, 185, 2, 2, 3802, 3801, 3, 2, 2, 2, 3802, 3803, 3, 2, 2, 2, 3803, 3804, 3, 2, 2, 2, 3804, 3805, 7, 126, 2, 2, 3805, 3857, 5, 618, 310, 2, 3806, 3807, 7, 189, 2, 2, 3807, 3857, 5, 528, 265, 2, 3808, 3809, 7, 211, 2, 2, 3809, 3857, 5, 528, 265, 2, 3810, 3811, 7, 217, 2, 2, 3811, 3812, 5, 528, 265, 2, 3812, 3813, 7, 419, 2, 2, 3813, 3814, 5, 618, 310, 2, 3814, 3857, 3, 2, 2, 2, 3815, 3816, 7, 219, 2, 2, 3816, 3857, 5, 528, 265, 2, 3817, 3818, 7, 225, 2, 2, 3818, 3857, 5, 618, 310, 2, 3819, 3820, 7, 228, 2, 2, 3820, 3857, 5, 528, 265, 2, 3821, 3822, 7, 242, 2, 2, 3822, 3857, 5, 618, 310, 2, 3823, 3824, 7, 249, 2, 2, 3824, 3857, 5, 528, 265, 2, 3825, 3826, 7, 254, 2, 2, 3826, 3857, 5, 528, 265, 2, 3827, 3828, 7, 258, 2, 2, 3828, 3829, 7, 222, 2, 2, 3829, 3830, 7, 40, 2, 2, 3830, 3857, 5, 618, 310, 2, 3831, 3832, 7, 258, 2, 2, 3832, 3833, 7, 222, 2, 2, 3833, 3834, 7, 67, 2, 2, 3834, 3857, 5, 618, 310, 2, 3835, 3836, 7, 258, 2, 2, 3836, 3837, 7, 222, 2, 2, 3837, 3838, 7, 172, 2, 2, 3838, 3857, 5, 618, 310, 2, 3839, 3840, 7, 258, 2, 2, 3840, 3841, 7, 222, 2, 2, 3841, 3842, 7, 256, 2, 2, 3842, 3857, 5, 618, 310, 2, 3843, 3844, 7, 261, 2, 2, 3844, 3845, 7, 401, 2, 2, 3845, 3846, 5, 618, 310, 2, 3846, 3847, 7, 126, 2, 2, 3847, 3848, 5, 528, 265, 2, 3848, 3857, 3, 2, 2, 2, 3849, 3850, 7, 262, 2, 2, 3850, 3851, 5, 528, 265, 2, 3851, 3852, 7, 419, 2, 2, 3852, 3853, 5, 618, 310, 2, 3853, 3857, 3, 2, 2, 2, 3854, 3855, 7, 265, 2, 2, 3855, 3857, 5, 618, 310, 2, 3856, 3732, 3, 2, 2, 2, 3856, 3735, 3, 2, 2, 2, 3856, 3739, 3, 2, 2, 2, 3856, 3746, 3, 2, 2, 2, 3856, 3748, 3, 2, 2, 2, 3856, 3750, 3, 2, 2, 2, 3856, 3758, 3, 2, 2, 2, 3856, 3760, 3, 2, 2, 2, 3856, 3762, 3, 2, 2, 2, 3856, 3764, 3, 2, 2, 2, 3856, 3766, 3, 2, 2, 2, 3856, 3769, 3, 2, 2, 2, 3856, 3774, 3, 2, 2, 2, 3856, 3778, 3, 2, 2, 2, 3856, 3780, 3, 2, 2, 2, 3856, 3784, 3, 2, 2, 2, 3856, 3788, 3, 2, 2, 2, 3856, 3790, 3, 2, 2, 2, 3856, 3796, 3, 2, 2, 2, 3856, 3802, 3, 2, 2, 2, 3856, 3806, 3, 2, 2, 2, 3856, 3808, 3, 2, 2, 2, 3856, 3810, 3, 2, 2, 2, 3856, 3815, 3, 2, 2, 2, 3856, 3817, 3, 2, 2, 2, 3856, 3819, 3, 2, 2, 2, 3856, 3821, 3, 2, 2, 2, 3856, 3823, 3, 2, 2, 2, 3856, 3825, 3, 2, 2, 2, 3856, 3827, 3, 2, 2, 2, 3856, 3831, 3, 2, 2, 2, 3856, 3835, 3, 2, 2, 2, 3856, 3839, 3, 2, 2, 2, 3856, 3843, 3, 2, 2, 2, 3856, 3849, 3, 2, 2, 2, 3856, 3854, 3, 2, 2, 2, 3857, 307, 3, 2, 2, 2, 3858, 3859, 9, 50, 2, 2, 3859, 3860, 5, 618, 310, 2, 3860, 3861, 5, 322, 162, 2, 3861, 3904, 3, 2, 2, 2, 3862, 3863, 7, 382, 2, 2, 3863, 3904, 5, 618, 310, 2, 3864, 3865, 7, 55, 2, 2, 3865, 3904, 5, 528, 265, 2, 3866, 3867, 7, 71, 2, 2, 3867, 3904, 5, 618, 310, 2, 3868, 3869, 7, 80, 2, 2, 3869, 3870, 7, 262, 2, 2, 3870, 3904, 5, 528, 265, 2, 3871, 3873, 7, 402, 2, 2, 3872, 3871, 3, 2, 2, 2, 3872, 3873, 3, 2, 2, 2, 3873, 3874, 3, 2, 2, 2, 3874, 3875, 7, 431, 2, 2, 3875, 3904, 5, 618, 310, 2, 3876, 3877, 7, 127, 2, 2, 3877, 3878, 7, 157, 2, 2, 3878, 3904, 7, 610, 2, 2, 3879, 3881, 7, 140, 2, 2, 3880, 3879, 3, 2, 2, 2, 3880, 3881, 3, 2, 2, 2, 3881, 3882, 3, 2, 2, 2, 3882, 3883, 7, 282, 2, 2, 3883, 3904, 5, 618, 310, 2, 3884, 3886, 7, 185, 2, 2, 3885, 3884, 3, 2, 2, 2, 3885, 3886, 3, 2, 2, 2, 3886, 3887, 3, 2, 2, 2, 3887, 3888, 7, 126, 2, 2, 3888, 3904, 5, 618, 310, 2, 3889, 3890, 7, 189, 2, 2, 3890, 3904, 5, 528, 265, 2, 3891, 3892, 7, 211, 2, 2, 3892, 3904, 5, 528, 265, 2, 3893, 3894, 7, 219, 2, 2, 3894, 3904, 5, 528, 265, 2, 3895, 3896, 7, 225, 2, 2, 3896, 3904, 5, 618, 310, 2, 3897, 3898, 7, 249, 2, 2, 3898, 3904, 5, 528, 265, 2, 3899, 3900, 7, 254, 2, 2, 3900, 3904, 5, 528, 265, 2, 3901, 3902, 7, 265, 2, 2, 3902, 3904, 5, 618, 310, 2, 3903, 3858, 3, 2, 2, 2, 3903, 3862, 3, 2, 2, 2, 3903, 3864, 3, 2, 2, 2, 3903, 3866, 3, 2, 2, 2, 3903, 3868, 3, 2, 2, 2, 3903, 3872, 3, 2, 2, 2, 3903, 3876, 3, 2, 2, 2, 3903, 3880, 3, 2, 2, 2, 3903, 3885, 3, 2, 2, 2, 3903, 3889, 3, 2, 2, 2, 3903, 3891, 3, 2, 2, 2, 3903, 3893, 3, 2, 2, 2, 3903, 3895, 3, 2, 2, 2, 3903, 3897, 3, 2, 2, 2, 3903, 3899, 3, 2, 2, 2, 3903, 3901, 3, 2, 2, 2, 3904, 309, 3, 2, 2, 2, 3905, 3906, 7, 421, 2, 2, 3906, 3908, 7, 204, 2, 2, 3907, 3905, 3, 2, 2, 2, 3907, 3908, 3, 2, 2, 2, 3908, 3909, 3, 2, 2, 2, 3909, 3910, 9, 18, 2, 2, 3910, 3916, 5, 320, 161, 2, 3911, 3914, 7, 209, 2, 2, 3912, 3915, 5, 548, 275, 2, 3913, 3915, 5, 316, 159, 2, 3914, 3912, 3, 2, 2, 2, 3914, 3913, 3, 2, 2, 2, 3915, 3917, 3, 2, 2, 2, 3916, 3911, 3, 2, 2, 2, 3916, 3917, 3, 2, 2, 2, 3917, 3918, 3, 2, 2, 2, 3918, 3919, 5, 312, 157, 2, 3919, 311, 3, 2, 2, 2, 3920, 3922, 5, 104, 53, 2, 3921, 3920, 3, 2, 2, 2, 3922, 3923, 3, 2, 2, 2, 3923, 3921, 3, 2, 2, 2, 3923, 3924, 3, 2, 2, 2, 3924, 3926, 3, 2, 2, 2, 3925, 3927, 5, 482, 242, 2, 3926, 3925, 3, 2, 2, 2, 3926, 3927, 3, 2, 2, 2, 3927, 313, 3, 2, 2, 2, 3928, 3929, 7, 401, 2, 2, 3929, 3930, 7, 265, 2, 2, 3930, 3931, 5, 548, 275, 2, 3931, 315, 3, 2, 2, 2, 3932, 3933, 7, 431, 2, 2, 3933, 3934, 7, 587, 2, 2, 3934, 3939, 5, 318, 160, 2, 3935, 3936, 7, 581, 2, 2, 3936, 3938, 5, 318, 160, 2, 3937, 3935, 3, 2, 2, 2, 3938, 3941, 3, 2, 2, 2, 3939, 3937, 3, 2, 2, 2, 3939, 3940, 3, 2, 2, 2, 3940, 3942, 3, 2, 2, 2, 3941, 3939, 3, 2, 2, 2, 3942, 3943, 7, 588, 2, 2, 3943, 317, 3, 2, 2, 2, 3944, 3945, 5, 528, 265, 2, 3945, 3946, 5, 548, 275, 2, 3946, 319, 3, 2, 2, 2, 3947, 3948, 5, 618, 310, 2, 3948, 3949, 5, 322, 162, 2, 3949, 321, 3, 2, 2, 2, 3950, 3965, 7, 587, 2, 2, 3951, 3956, 5, 328, 165, 2, 3952, 3953, 7, 581, 2, 2, 3953, 3955, 5, 328, 165, 2, 3954, 3952, 3, 2, 2, 2, 3955, 3958, 3, 2, 2, 2, 3956, 3954, 3, 2, 2, 2, 3956, 3957, 3, 2, 2, 2, 3957, 3960, 3, 2, 2, 2, 3958, 3956, 3, 2, 2, 2, 3959, 3951, 3, 2, 2, 2, 3959, 3960, 3, 2, 2, 2, 3960, 3962, 3, 2, 2, 2, 3961, 3963, 5, 324, 163, 2, 3962, 3961, 3, 2, 2, 2, 3962, 3963, 3, 2, 2, 2, 3963, 3966, 3, 2, 2, 2, 3964, 3966, 7, 591, 2, 2, 3965, 3959, 3, 2, 2, 2, 3965, 3964, 3, 2, 2, 2, 3966, 3967, 3, 2, 2, 2, 3967, 3968, 7, 588, 2, 2, 3968, 323, 3, 2, 2, 2, 3969, 3970, 7, 422, 2, 2, 3970, 3971, 7, 22, 2, 2, 3971, 3976, 5, 328, 165, 2, 3972, 3973, 7, 581, 2, 2, 3973, 3975, 5, 328, 165, 2, 3974, 3972, 3, 2, 2, 2, 3975, 3978, 3, 2, 2, 2, 3976, 3974, 3, 2, 2, 2, 3976, 3977, 3, 2, 2, 2, 3977, 325, 3, 2, 2, 2, 3978, 3976, 3, 2, 2, 2, 3979, 3983, 7, 616, 2, 2, 3980, 3982, 7, 623, 2, 2, 3981, 3980, 3, 2, 2, 2, 3982, 3985, 3, 2, 2, 2, 3983, 3981, 3, 2, 2, 2, 3983, 3984, 3, 2, 2, 2, 3984, 3986, 3, 2, 2, 2, 3985, 3983, 3, 2, 2, 2, 3986, 3989, 7, 624, 2, 2, 3987, 3989, 7, 615, 2, 2, 3988, 3979, 3, 2, 2, 2, 3988, 3987, 3, 2, 2, 2, 3989, 327, 3, 2, 2, 2, 3990, 3992, 5, 330, 166, 2, 3991, 3990, 3, 2, 2, 2, 3991, 3992, 3, 2, 2, 2, 3992, 3994, 3, 2, 2, 2, 3993, 3995, 5, 530, 266, 2, 3994, 3993, 3, 2, 2, 2, 3994, 3995, 3, 2, 2, 2, 3995, 3996, 3, 2, 2, 2, 3996, 3999, 5, 548, 275, 2, 3997, 3998, 9, 52, 2, 2, 3998, 4000, 5, 560, 281, 2, 3999, 3997, 3, 2, 2, 2, 3999, 4000, 3, 2, 2, 2, 4000, 329, 3, 2, 2, 2, 4001, 4002, 9, 53, 2, 2, 4002, 331, 3, 2, 2, 2, 4003, 4005, 9, 54, 2, 2, 4004, 4003, 3, 2, 2, 2, 4004, 4005, 3, 2, 2, 2, 4005, 4006, 3, 2, 2, 2, 4006, 4008, 7, 225, 2, 2, 4007, 4009, 5, 410, 206, 2, 4008, 4007, 3, 2, 2, 2, 4008, 4009, 3, 2, 2, 2, 4009, 4010, 3, 2, 2, 2, 4010, 4014, 5, 618, 310, 2, 4011, 4013, 5, 334, 168, 2, 4012, 4011, 3, 2, 2, 2, 4013, 4016, 3, 2, 2, 2, 4014, 4012, 3, 2, 2, 2, 4014, 4015, 3, 2, 2, 2, 4015, 333, 3, 2, 2, 2, 4016, 4014, 3, 2, 2, 2, 4017, 4018, 7, 374, 2, 2, 4018, 4054, 9, 55, 2, 2, 4019, 4020, 7, 225, 2, 2, 4020, 4021, 7, 148, 2, 2, 4021, 4054, 5, 618, 310, 2, 4022, 4024, 7, 112, 2, 2, 4023, 4025, 7, 22, 2, 2, 4024, 4023, 3, 2, 2, 2, 4024, 4025, 3, 2, 2, 2, 4025, 4026, 3, 2, 2, 2, 4026, 4054, 5, 338, 170, 2, 4027, 4028, 7, 144, 2, 2, 4028, 4032, 5, 338, 170, 2, 4029, 4030, 7, 152, 2, 2, 4030, 4032, 7, 144, 2, 2, 4031, 4027, 3, 2, 2, 2, 4031, 4029, 3, 2, 2, 2, 4032, 4054, 3, 2, 2, 2, 4033, 4034, 7, 141, 2, 2, 4034, 4038, 5, 338, 170, 2, 4035, 4036, 7, 152, 2, 2, 4036, 4038, 7, 141, 2, 2, 4037, 4033, 3, 2, 2, 2, 4037, 4035, 3, 2, 2, 2, 4038, 4054, 3, 2, 2, 2, 4039, 4041, 7, 240, 2, 2, 4040, 4042, 7, 444, 2, 2, 4041, 4040, 3, 2, 2, 2, 4041, 4042, 3, 2, 2, 2, 4042, 4043, 3, 2, 2, 2, 4043, 4054, 5, 338, 170, 2, 4044, 4045, 7, 23, 2, 2, 4045, 4054, 5, 338, 170, 2, 4046, 4048, 7, 152, 2, 2, 4047, 4046, 3, 2, 2, 2, 4047, 4048, 3, 2, 2, 2, 4048, 4049, 3, 2, 2, 2, 4049, 4054, 7, 53, 2, 2, 4050, 4051, 7, 169, 2, 2, 4051, 4052, 7, 22, 2, 2, 4052, 4054, 5, 618, 310, 2, 4053, 4017, 3, 2, 2, 2, 4053, 4019, 3, 2, 2, 2, 4053, 4022, 3, 2, 2, 2, 4053, 4031, 3, 2, 2, 2, 4053, 4037, 3, 2, 2, 2, 4053, 4039, 3, 2, 2, 2, 4053, 4044, 3, 2, 2, 2, 4053, 4047, 3, 2, 2, 2, 4053, 4050, 3, 2, 2, 2, 4054, 335, 3, 2, 2, 2, 4055, 4057, 5, 340, 171, 2, 4056, 4055, 3, 2, 2, 2, 4056, 4057, 3, 2, 2, 2, 4057, 4058, 3, 2, 2, 2, 4058, 4059, 7, 610, 2, 2, 4059, 337, 3, 2, 2, 2, 4060, 4062, 5, 340, 171, 2, 4061, 4060, 3, 2, 2, 2, 4061, 4062, 3, 2, 2, 2, 4062, 4063, 3, 2, 2, 2, 4063, 4064, 5, 574, 288, 2, 4064, 339, 3, 2, 2, 2, 4065, 4066, 9, 56, 2, 2, 4066, 341, 3, 2, 2, 2, 4067, 4069, 7, 219, 2, 2, 4068, 4070, 5, 410, 206, 2, 4069, 4068, 3, 2, 2, 2, 4069, 4070, 3, 2, 2, 2, 4070, 4072, 3, 2, 2, 2, 4071, 4073, 5, 528, 265, 2, 4072, 4071, 3, 2, 2, 2, 4072, 4073, 3, 2, 2, 2, 4073, 4076, 3, 2, 2, 2, 4074, 4075, 7, 345, 2, 2, 4075, 4077, 5, 44, 23, 2, 4076, 4074, 3, 2, 2, 2, 4076, 4077, 3, 2, 2, 2, 4077, 343, 3, 2, 2, 2, 4078, 4079, 7, 178, 2, 2, 4079, 4080, 5, 528, 265, 2, 4080, 4081, 7, 419, 2, 2, 4081, 4084, 5, 618, 310, 2, 4082, 4083, 7, 374, 2, 2, 4083, 4085, 9, 57, 2, 2, 4084, 4082, 3, 2, 2, 2, 4084, 4085, 3, 2, 2, 2, 4085, 4088, 3, 2, 2, 2, 4086, 4087, 7, 401, 2, 2, 4087, 4089, 9, 58, 2, 2, 4088, 4086, 3, 2, 2, 2, 4088, 4089, 3, 2, 2, 2, 4089, 4099, 3, 2, 2, 2, 4090, 4091, 7, 433, 2, 2, 4091, 4096, 5, 44, 23, 2, 4092, 4093, 7, 581, 2, 2, 4093, 4095, 5, 44, 23, 2, 4094, 4092, 3, 2, 2, 2, 4095, 4098, 3, 2, 2, 2, 4096, 4094, 3, 2, 2, 2, 4096, 4097, 3, 2, 2, 2, 4097, 4100, 3, 2, 2, 2, 4098, 4096, 3, 2, 2, 2, 4099, 4090, 3, 2, 2, 2, 4099, 4100, 3, 2, 2, 2, 4100, 4103, 3, 2, 2, 2, 4101, 4102, 7, 439, 2, 2, 4102, 4104, 5, 560, 281, 2, 4103, 4101, 3, 2, 2, 2, 4103, 4104, 3, 2, 2, 2, 4104, 4108, 3, 2, 2, 2, 4105, 4106, 7, 444, 2, 2, 4106, 4107, 7, 380, 2, 2, 4107, 4109, 5, 560, 281, 2, 4108, 4105, 3, 2, 2, 2, 4108, 4109, 3, 2, 2, 2, 4109, 345, 3, 2, 2, 2, 4110, 4111, 7, 178, 2, 2, 4111, 4112, 5, 528, 265, 2, 4112, 4113, 7, 419, 2, 2, 4113, 4114, 5, 618, 310, 2, 4114, 4115, 5, 494, 248, 2, 4115, 4141, 3, 2, 2, 2, 4116, 4117, 7, 178, 2, 2, 4117, 4118, 5, 528, 265, 2, 4118, 4119, 7, 419, 2, 2, 4119, 4129, 5, 618, 310, 2, 4120, 4121, 7, 433, 2, 2, 4121, 4126, 5, 44, 23, 2, 4122, 4123, 7, 581, 2, 2, 4123, 4125, 5, 44, 23, 2, 4124, 4122, 3, 2, 2, 2, 4125, 4128, 3, 2, 2, 2, 4126, 4124, 3, 2, 2, 2, 4126, 4127, 3, 2, 2, 2, 4127, 4130, 3, 2, 2, 2, 4128, 4126, 3, 2, 2, 2, 4129, 4120, 3, 2, 2, 2, 4129, 4130, 3, 2, 2, 2, 4130, 4133, 3, 2, 2, 2, 4131, 4132, 7, 439, 2, 2, 4132, 4134, 5, 560, 281, 2, 4133, 4131, 3, 2, 2, 2, 4133, 4134, 3, 2, 2, 2, 4134, 4138, 3, 2, 2, 2, 4135, 4136, 7, 444, 2, 2, 4136, 4137, 7, 380, 2, 2, 4137, 4139, 5, 560, 281, 2, 4138, 4135, 3, 2, 2, 2, 4138, 4139, 3, 2, 2, 2, 4139, 4141, 3, 2, 2, 2, 4140, 4110, 3, 2, 2, 2, 4140, 4116, 3, 2, 2, 2, 4141, 347, 3, 2, 2, 2, 4142, 4144, 7, 178, 2, 2, 4143, 4145, 5, 408, 205, 2, 4144, 4143, 3, 2, 2, 2, 4144, 4145, 3, 2, 2, 2, 4145, 4146, 3, 2, 2, 2, 4146, 4147, 5, 528, 265, 2, 4147, 4148, 7, 419, 2, 2, 4148, 4150, 5, 618, 310, 2, 4149, 4151, 5, 504, 253, 2, 4150, 4149, 3, 2, 2, 2, 4150, 4151, 3, 2, 2, 2, 4151, 349, 3, 2, 2, 2, 4152, 4153, 7, 249, 2, 2, 4153, 4154, 5, 528, 265, 2, 4154, 4155, 7, 42, 2, 2, 4155, 4156, 7, 615, 2, 2, 4156, 4157, 7, 189, 2, 2, 4157, 4159, 5, 694, 348, 2, 4158, 4160, 5, 482, 242, 2, 4159, 4158, 3, 2, 2, 2, 4159, 4160, 3, 2, 2, 2, 4160, 351, 3, 2, 2, 2, 4161, 4162, 7, 249, 2, 2, 4162, 4163, 5, 528, 265, 2, 4163, 4164, 5, 354, 178, 2, 4164, 353, 3, 2, 2, 2, 4165, 4166, 7, 42, 2, 2, 4166, 4185, 5, 326, 164, 2, 4167, 4168, 7, 230, 2, 2, 4168, 4169, 7, 189, 2, 2, 4169, 4171, 5, 694, 348, 2, 4170, 4172, 5, 482, 242, 2, 4171, 4170, 3, 2, 2, 2, 4171, 4172, 3, 2, 2, 2, 4172, 4185, 3, 2, 2, 2, 4173, 4174, 7, 198, 2, 2, 4174, 4176, 7, 189, 2, 2, 4175, 4177, 5, 482, 242, 2, 4176, 4175, 3, 2, 2, 2, 4176, 4177, 3, 2, 2, 2, 4177, 4185, 3, 2, 2, 2, 4178, 4185, 7, 75, 2, 2, 4179, 4185, 7, 68, 2, 2, 4180, 4181, 7, 230, 2, 2, 4181, 4185, 5, 476, 239, 2, 4182, 4185, 5, 492, 247, 2, 4183, 4185, 5, 494, 248, 2, 4184, 4165, 3, 2, 2, 2, 4184, 4167, 3, 2, 2, 2, 4184, 4173, 3, 2, 2, 2, 4184, 4178, 3, 2, 2, 2, 4184, 4179, 3, 2, 2, 2, 4184, 4180, 3, 2, 2, 2, 4184, 4182, 3, 2, 2, 2, 4184, 4183, 3, 2, 2, 2, 4185, 355, 3, 2, 2, 2, 4186, 4187, 7, 379, 2, 2, 4187, 4188, 7, 587, 2, 2, 4188, 4189, 5, 548, 275, 2, 4189, 4190, 7, 374, 2, 2, 4190, 4191, 5, 548, 275, 2, 4191, 4201, 7, 588, 2, 2, 4192, 4193, 7, 444, 2, 2, 4193, 4194, 7, 94, 2, 2, 4194, 4195, 5, 618, 310, 2, 4195, 4196, 5, 322, 162, 2, 4196, 4202, 3, 2, 2, 2, 4197, 4198, 7, 287, 2, 2, 4198, 4202, 7, 94, 2, 2, 4199, 4200, 7, 444, 2, 2, 4200, 4202, 7, 309, 2, 2, 4201, 4192, 3, 2, 2, 2, 4201, 4197, 3, 2, 2, 2, 4201, 4199, 3, 2, 2, 2, 4202, 4207, 3, 2, 2, 2, 4203, 4204, 7, 374, 2, 2, 4204, 4208, 7, 15, 2, 2, 4205, 4206, 7, 374, 2, 2, 4206, 4208, 7, 108, 2, 2, 4207, 4203, 3, 2, 2, 2, 4207, 4205, 3, 2, 2, 2, 4207, 4208, 3, 2, 2, 2, 4208, 357, 3, 2, 2, 2, 4209, 4211, 7, 379, 2, 2, 4210, 4212, 5, 408, 205, 2, 4211, 4210, 3, 2, 2, 2, 4211, 4212, 3, 2, 2, 2, 4212, 4213, 3, 2, 2, 2, 4213, 4214, 7, 587, 2, 2, 4214, 4215, 5, 548, 275, 2, 4215, 4216, 7, 374, 2, 2, 4216, 4217, 5, 548, 275, 2, 4217, 4219, 7, 588, 2, 2, 4218, 4220, 5, 504, 253, 2, 4219, 4218, 3, 2, 2, 2, 4219, 4220, 3, 2, 2, 2, 4220, 359, 3, 2, 2, 2, 4221, 4222, 7, 162, 2, 2, 4222, 4223, 7, 88, 2, 2, 4223, 4224, 5, 618, 310, 2, 4224, 4225, 7, 439, 2, 2, 4225, 4226, 5, 528, 265, 2, 4226, 361, 3, 2, 2, 2, 4227, 4228, 7, 162, 2, 2, 4228, 4229, 7, 88, 2, 2, 4229, 4230, 5, 618, 310, 2, 4230, 4231, 7, 439, 2, 2, 4231, 4232, 5, 528, 265, 2, 4232, 4233, 5, 364, 183, 2, 4233, 363, 3, 2, 2, 2, 4234, 4256, 5, 494, 248, 2, 4235, 4256, 5, 492, 247, 2, 4236, 4256, 5, 496, 249, 2, 4237, 4238, 7, 7, 2, 2, 4238, 4243, 5, 366, 184, 2, 4239, 4240, 7, 581, 2, 2, 4240, 4242, 5, 366, 184, 2, 4241, 4239, 3, 2, 2, 2, 4242, 4245, 3, 2, 2, 2, 4243, 4241, 3, 2, 2, 2, 4243, 4244, 3, 2, 2, 2, 4244, 4256, 3, 2, 2, 2, 4245, 4243, 3, 2, 2, 2, 4246, 4247, 7, 73, 2, 2, 4247, 4252, 5, 368, 185, 2, 4248, 4249, 7, 581, 2, 2, 4249, 4251, 5, 368, 185, 2, 4250, 4248, 3, 2, 2, 2, 4251, 4254, 3, 2, 2, 2, 4252, 4250, 3, 2, 2, 2, 4252, 4253, 3, 2, 2, 2, 4253, 4256, 3, 2, 2, 2, 4254, 4252, 3, 2, 2, 2, 4255, 4234, 3, 2, 2, 2, 4255, 4235, 3, 2, 2, 2, 4255, 4236, 3, 2, 2, 2, 4255, 4237, 3, 2, 2, 2, 4255, 4246, 3, 2, 2, 2, 4256, 365, 3, 2, 2, 2, 4257, 4258, 7, 162, 2, 2, 4258, 4259, 5, 574, 288, 2, 4259, 4266, 5, 220, 111, 2, 4260, 4261, 7, 401, 2, 2, 4261, 4267, 7, 222, 2, 2, 4262, 4263, 7, 401, 2, 2, 4263, 4264, 7, 422, 2, 2, 4264, 4265, 7, 22, 2, 2, 4265, 4267, 5, 618, 310, 2, 4266, 4260, 3, 2, 2, 2, 4266, 4262, 3, 2, 2, 2, 4266, 4267, 3, 2, 2, 2, 4267, 4288, 3, 2, 2, 2, 4268, 4269, 7, 94, 2, 2, 4269, 4283, 5, 574, 288, 2, 4270, 4273, 7, 587, 2, 2, 4271, 4274, 5, 548, 275, 2, 4272, 4274, 7, 316, 2, 2, 4273, 4271, 3, 2, 2, 2, 4273, 4272, 3, 2, 2, 2, 4274, 4280, 3, 2, 2, 2, 4275, 4278, 7, 581, 2, 2, 4276, 4279, 5, 548, 275, 2, 4277, 4279, 7, 316, 2, 2, 4278, 4276, 3, 2, 2, 2, 4278, 4277, 3, 2, 2, 2, 4279, 4281, 3, 2, 2, 2, 4280, 4275, 3, 2, 2, 2, 4280, 4281, 3, 2, 2, 2, 4281, 4282, 3, 2, 2, 2, 4282, 4284, 7, 588, 2, 2, 4283, 4270, 3, 2, 2, 2, 4283, 4284, 3, 2, 2, 2, 4284, 4285, 3, 2, 2, 2, 4285, 4286, 5, 582, 292, 2, 4286, 4288, 3, 2, 2, 2, 4287, 4257, 3, 2, 2, 2, 4287, 4268, 3, 2, 2, 2, 4288, 367, 3, 2, 2, 2, 4289, 4290, 9, 59, 2, 2, 4290, 4291, 5, 574, 288, 2, 4291, 4294, 7, 587, 2, 2, 4292, 4295, 5, 548, 275, 2, 4293, 4295, 7, 316, 2, 2, 4294, 4292, 3, 2, 2, 2, 4294, 4293, 3, 2, 2, 2, 4295, 4301, 3, 2, 2, 2, 4296, 4299, 7, 581, 2, 2, 4297, 4300, 5, 548, 275, 2, 4298, 4300, 7, 316, 2, 2, 4299, 4297, 3, 2, 2, 2, 4299, 4298, 3, 2, 2, 2, 4300, 4302, 3, 2, 2, 2, 4301, 4296, 3, 2, 2, 2, 4301, 4302, 3, 2, 2, 2, 4302, 4303, 3, 2, 2, 2, 4303, 4304, 7, 588, 2, 2, 4304, 369, 3, 2, 2, 2, 4305, 4306, 7, 162, 2, 2, 4306, 4308, 7, 88, 2, 2, 4307, 4309, 5, 408, 205, 2, 4308, 4307, 3, 2, 2, 2, 4308, 4309, 3, 2, 2, 2, 4309, 4310, 3, 2, 2, 2, 4310, 4311, 5, 618, 310, 2, 4311, 4312, 7, 439, 2, 2, 4312, 4314, 5, 528, 265, 2, 4313, 4315, 5, 504, 253, 2, 4314, 4313, 3, 2, 2, 2, 4314, 4315, 3, 2, 2, 2, 4315, 371, 3, 2, 2, 2, 4316, 4317, 7, 162, 2, 2, 4317, 4318, 7, 32, 2, 2, 4318, 4320, 5, 618, 310, 2, 4319, 4321, 7, 391, 2, 2, 4320, 4319, 3, 2, 2, 2, 4320, 4321, 3, 2, 2, 2, 4321, 4322, 3, 2, 2, 2, 4322, 4323, 7, 401, 2, 2, 4323, 4324, 7, 265, 2, 2, 4324, 4325, 5, 548, 275, 2, 4325, 4326, 7, 439, 2, 2, 4326, 4329, 5, 528, 265, 2, 4327, 4328, 7, 88, 2, 2, 4328, 4330, 5, 618, 310, 2, 4329, 4327, 3, 2, 2, 2, 4329, 4330, 3, 2, 2, 2, 4330, 4331, 3, 2, 2, 2, 4331, 4332, 7, 374, 2, 2, 4332, 4337, 5, 374, 188, 2, 4333, 4334, 7, 581, 2, 2, 4334, 4336, 5, 374, 188, 2, 4335, 4333, 3, 2, 2, 2, 4336, 4339, 3, 2, 2, 2, 4337, 4335, 3, 2, 2, 2, 4337, 4338, 3, 2, 2, 2, 4338, 373, 3, 2, 2, 2, 4339, 4337, 3, 2, 2, 2, 4340, 4341, 7, 162, 2, 2, 4341, 4342, 5, 574, 288, 2, 4342, 4354, 5, 254, 128, 2, 4343, 4346, 7, 587, 2, 2, 4344, 4347, 5, 548, 275, 2, 4345, 4347, 7, 316, 2, 2, 4346, 4344, 3, 2, 2, 2, 4346, 4345, 3, 2, 2, 2, 4347, 4348, 3, 2, 2, 2, 4348, 4351, 7, 581, 2, 2, 4349, 4352, 5, 548, 275, 2, 4350, 4352, 7, 316, 2, 2, 4351, 4349, 3, 2, 2, 2, 4351, 4350, 3, 2, 2, 2, 4352, 4353, 3, 2, 2, 2, 4353, 4355, 7, 588, 2, 2, 4354, 4343, 3, 2, 2, 2, 4354, 4355, 3, 2, 2, 2, 4355, 4362, 3, 2, 2, 2, 4356, 4357, 7, 401, 2, 2, 4357, 4363, 7, 222, 2, 2, 4358, 4359, 7, 401, 2, 2, 4359, 4360, 7, 422, 2, 2, 4360, 4361, 7, 22, 2, 2, 4361, 4363, 5, 618, 310, 2, 4362, 4356, 3, 2, 2, 2, 4362, 4358, 3, 2, 2, 2, 4362, 4363, 3, 2, 2, 2, 4363, 4386, 3, 2, 2, 2, 4364, 4365, 7, 94, 2, 2, 4365, 4379, 5, 574, 288, 2, 4366, 4369, 7, 587, 2, 2, 4367, 4370, 5, 548, 275, 2, 4368, 4370, 7, 316, 2, 2, 4369, 4367, 3, 2, 2, 2, 4369, 4368, 3, 2, 2, 2, 4370, 4376, 3, 2, 2, 2, 4371, 4374, 7, 581, 2, 2, 4372, 4375, 5, 548, 275, 2, 4373, 4375, 7, 316, 2, 2, 4374, 4372, 3, 2, 2, 2, 4374, 4373, 3, 2, 2, 2, 4375, 4377, 3, 2, 2, 2, 4376, 4371, 3, 2, 2, 2, 4376, 4377, 3, 2, 2, 2, 4377, 4378, 3, 2, 2, 2, 4378, 4380, 7, 588, 2, 2, 4379, 4366, 3, 2, 2, 2, 4379, 4380, 3, 2, 2, 2, 4380, 4381, 3, 2, 2, 2, 4381, 4382, 5, 582, 292, 2, 4382, 4386, 3, 2, 2, 2, 4383, 4384, 7, 245, 2, 2, 4384, 4386, 5, 548, 275, 2, 4385, 4340, 3, 2, 2, 2, 4385, 4364, 3, 2, 2, 2, 4385, 4383, 3, 2, 2, 2, 4386, 375, 3, 2, 2, 2, 4387, 4388, 7, 162, 2, 2, 4388, 4389, 7, 32, 2, 2, 4389, 4390, 5, 618, 310, 2, 4390, 4391, 7, 439, 2, 2, 4391, 4395, 5, 528, 265, 2, 4392, 4396, 5, 494, 248, 2, 4393, 4396, 5, 492, 247, 2, 4394, 4396, 5, 496, 249, 2, 4395, 4392, 3, 2, 2, 2, 4395, 4393, 3, 2, 2, 2, 4395, 4394, 3, 2, 2, 2, 4396, 377, 3, 2, 2, 2, 4397, 4398, 7, 162, 2, 2, 4398, 4400, 7, 32, 2, 2, 4399, 4401, 5, 408, 205, 2, 4400, 4399, 3, 2, 2, 2, 4400, 4401, 3, 2, 2, 2, 4401, 4402, 3, 2, 2, 2, 4402, 4403, 5, 618, 310, 2, 4403, 4404, 7, 439, 2, 2, 4404, 4406, 5, 528, 265, 2, 4405, 4407, 5, 504, 253, 2, 4406, 4405, 3, 2, 2, 2, 4406, 4407, 3, 2, 2, 2, 4407, 379, 3, 2, 2, 2, 4408, 4410, 7, 391, 2, 2, 4409, 4408, 3, 2, 2, 2, 4409, 4410, 3, 2, 2, 2, 4410, 4411, 3, 2, 2, 2, 4411, 4412, 7, 46, 2, 2, 4412, 4413, 5, 618, 310, 2, 4413, 4414, 7, 401, 2, 2, 4414, 4415, 7, 615, 2, 2, 4415, 4416, 7, 433, 2, 2, 4416, 4417, 7, 615, 2, 2, 4417, 4418, 7, 403, 2, 2, 4418, 4419, 5, 618, 310, 2, 4419, 381, 3, 2, 2, 2, 4420, 4421, 7, 46, 2, 2, 4421, 4425, 5, 618, 310, 2, 4422, 4426, 5, 494, 248, 2, 4423, 4426, 5, 492, 247, 2, 4424, 4426, 5, 496, 249, 2, 4425, 4422, 3, 2, 2, 2, 4425, 4423, 3, 2, 2, 2, 4425, 4424, 3, 2, 2, 2, 4426, 383, 3, 2, 2, 2, 4427, 4428, 7, 189, 2, 2, 4428, 4442, 5, 528, 265, 2, 4429, 4430, 7, 401, 2, 2, 4430, 4431, 7, 431, 2, 2, 4431, 4436, 5, 390, 196, 2, 4432, 4433, 7, 581, 2, 2, 4433, 4435, 5, 390, 196, 2, 4434, 4432, 3, 2, 2, 2, 4435, 4438, 3, 2, 2, 2, 4436, 4434, 3, 2, 2, 2, 4436, 4437, 3, 2, 2, 2, 4437, 4443, 3, 2, 2, 2, 4438, 4436, 3, 2, 2, 2, 4439, 4440, 7, 401, 2, 2, 4440, 4441, 7, 368, 2, 2, 4441, 4443, 7, 253, 2, 2, 4442, 4429, 3, 2, 2, 2, 4442, 4439, 3, 2, 2, 2, 4442, 4443, 3, 2, 2, 2, 4443, 4445, 3, 2, 2, 2, 4444, 4446, 5, 482, 242, 2, 4445, 4444, 3, 2, 2, 2, 4445, 4446, 3, 2, 2, 2, 4446, 385, 3, 2, 2, 2, 4447, 4448, 7, 189, 2, 2, 4448, 4449, 5, 528, 265, 2, 4449, 4450, 5, 388, 195, 2, 4450, 387, 3, 2, 2, 2, 4451, 4466, 5, 494, 248, 2, 4452, 4466, 5, 492, 247, 2, 4453, 4454, 7, 230, 2, 2, 4454, 4466, 5, 476, 239, 2, 4455, 4456, 9, 60, 2, 2, 4456, 4457, 7, 431, 2, 2, 4457, 4462, 5, 390, 196, 2, 4458, 4459, 7, 581, 2, 2, 4459, 4461, 5, 390, 196, 2, 4460, 4458, 3, 2, 2, 2, 4461, 4464, 3, 2, 2, 2, 4462, 4460, 3, 2, 2, 2, 4462, 4463, 3, 2, 2, 2, 4463, 4466, 3, 2, 2, 2, 4464, 4462, 3, 2, 2, 2, 4465, 4451, 3, 2, 2, 2, 4465, 4452, 3, 2, 2, 2, 4465, 4453, 3, 2, 2, 2, 4465, 4455, 3, 2, 2, 2, 4466, 389, 3, 2, 2, 2, 4467, 4469, 7, 420, 2, 2, 4468, 4467, 3, 2, 2, 2, 4468, 4469, 3, 2, 2, 2, 4469, 4470, 3, 2, 2, 2, 4470, 4472, 5, 618, 310, 2, 4471, 4473, 7, 591, 2, 2, 4472, 4471, 3, 2, 2, 2, 4472, 4473, 3, 2, 2, 2, 4473, 391, 3, 2, 2, 2, 4474, 4475, 7, 262, 2, 2, 4475, 4476, 5, 528, 265, 2, 4476, 4477, 7, 419, 2, 2, 4477, 4483, 5, 618, 310, 2, 4478, 4484, 5, 494, 248, 2, 4479, 4480, 7, 65, 2, 2, 4480, 4481, 7, 419, 2, 2, 4481, 4482, 7, 86, 2, 2, 4482, 4484, 5, 528, 265, 2, 4483, 4478, 3, 2, 2, 2, 4483, 4479, 3, 2, 2, 2, 4484, 393, 3, 2, 2, 2, 4485, 4486, 7, 217, 2, 2, 4486, 4487, 5, 528, 265, 2, 4487, 4488, 7, 419, 2, 2, 4488, 4489, 5, 618, 310, 2, 4489, 4490, 5, 494, 248, 2, 4490, 395, 3, 2, 2, 2, 4491, 4494, 5, 400, 201, 2, 4492, 4494, 5, 398, 200, 2, 4493, 4491, 3, 2, 2, 2, 4493, 4492, 3, 2, 2, 2, 4494, 397, 3, 2, 2, 2, 4495, 4496, 7, 47, 2, 2, 4496, 4497, 5, 48, 25, 2, 4497, 4503, 7, 403, 2, 2, 4498, 4500, 7, 188, 2, 2, 4499, 4498, 3, 2, 2, 2, 4499, 4500, 3, 2, 2, 2, 4500, 4501, 3, 2, 2, 2, 4501, 4504, 7, 615, 2, 2, 4502, 4504, 7, 243, 2, 2, 4503, 4499, 3, 2, 2, 2, 4503, 4502, 3, 2, 2, 2, 4504, 4515, 3, 2, 2, 2, 4505, 4507, 7, 444, 2, 2, 4506, 4505, 3, 2, 2, 2, 4506, 4507, 3, 2, 2, 2, 4507, 4513, 3, 2, 2, 2, 4508, 4509, 7, 587, 2, 2, 4509, 4510, 5, 402, 202, 2, 4510, 4511, 7, 588, 2, 2, 4511, 4514, 3, 2, 2, 2, 4512, 4514, 5, 402, 202, 2, 4513, 4508, 3, 2, 2, 2, 4513, 4512, 3, 2, 2, 2, 4514, 4516, 3, 2, 2, 2, 4515, 4506, 3, 2, 2, 2, 4515, 4516, 3, 2, 2, 2, 4516, 4519, 3, 2, 2, 2, 4517, 4518, 7, 442, 2, 2, 4518, 4520, 5, 560, 281, 2, 4519, 4517, 3, 2, 2, 2, 4519, 4520, 3, 2, 2, 2, 4520, 399, 3, 2, 2, 2, 4521, 4527, 7, 47, 2, 2, 4522, 4528, 5, 48, 25, 2, 4523, 4524, 7, 587, 2, 2, 4524, 4525, 5, 16, 9, 2, 4525, 4526, 7, 588, 2, 2, 4526, 4528, 3, 2, 2, 2, 4527, 4522, 3, 2, 2, 2, 4527, 4523, 3, 2, 2, 2, 4528, 4529, 3, 2, 2, 2, 4529, 4535, 7, 433, 2, 2, 4530, 4532, 7, 188, 2, 2, 4531, 4530, 3, 2, 2, 2, 4531, 4532, 3, 2, 2, 2, 4532, 4533, 3, 2, 2, 2, 4533, 4536, 7, 615, 2, 2, 4534, 4536, 7, 244, 2, 2, 4535, 4531, 3, 2, 2, 2, 4535, 4534, 3, 2, 2, 2, 4536, 4547, 3, 2, 2, 2, 4537, 4539, 7, 444, 2, 2, 4538, 4537, 3, 2, 2, 2, 4538, 4539, 3, 2, 2, 2, 4539, 4545, 3, 2, 2, 2, 4540, 4541, 7, 587, 2, 2, 4541, 4542, 5, 402, 202, 2, 4542, 4543, 7, 588, 2, 2, 4543, 4546, 3, 2, 2, 2, 4544, 4546, 5, 402, 202, 2, 4545, 4540, 3, 2, 2, 2, 4545, 4544, 3, 2, 2, 2, 4546, 4548, 3, 2, 2, 2, 4547, 4538, 3, 2, 2, 2, 4547, 4548, 3, 2, 2, 2, 4548, 401, 3, 2, 2, 2, 4549, 4556, 5, 404, 203, 2, 4550, 4552, 7, 581, 2, 2, 4551, 4550, 3, 2, 2, 2, 4551, 4552, 3, 2, 2, 2, 4552, 4553, 3, 2, 2, 2, 4553, 4555, 5, 404, 203, 2, 4554, 4551, 3, 2, 2, 2, 4555, 4558, 3, 2, 2, 2, 4556, 4554, 3, 2, 2, 2, 4556, 4557, 3, 2, 2, 2, 4557, 403, 3, 2, 2, 2, 4558, 4556, 3, 2, 2, 2, 4559, 4561, 7, 469, 2, 2, 4560, 4559, 3, 2, 2, 2, 4560, 4561, 3, 2, 2, 2, 4561, 4562, 3, 2, 2, 2, 4562, 4620, 9, 61, 2, 2, 4563, 4565, 7, 160, 2, 2, 4564, 4566, 5, 576, 289, 2, 4565, 4564, 3, 2, 2, 2, 4565, 4566, 3, 2, 2, 2, 4566, 4620, 3, 2, 2, 2, 4567, 4569, 7, 351, 2, 2, 4568, 4570, 5, 576, 289, 2, 4569, 4568, 3, 2, 2, 2, 4569, 4570, 3, 2, 2, 2, 4570, 4620, 3, 2, 2, 2, 4571, 4573, 7, 63, 2, 2, 4572, 4574, 7, 374, 2, 2, 4573, 4572, 3, 2, 2, 2, 4573, 4574, 3, 2, 2, 2, 4574, 4575, 3, 2, 2, 2, 4575, 4620, 7, 615, 2, 2, 4576, 4578, 7, 417, 2, 2, 4577, 4579, 7, 374, 2, 2, 4578, 4577, 3, 2, 2, 2, 4578, 4579, 3, 2, 2, 2, 4579, 4580, 3, 2, 2, 2, 4580, 4620, 7, 615, 2, 2, 4581, 4583, 7, 101, 2, 2, 4582, 4584, 5, 576, 289, 2, 4583, 4582, 3, 2, 2, 2, 4583, 4584, 3, 2, 2, 2, 4584, 4620, 3, 2, 2, 2, 4585, 4586, 7, 190, 2, 2, 4586, 4620, 7, 615, 2, 2, 4587, 4588, 7, 79, 2, 2, 4588, 4620, 7, 615, 2, 2, 4589, 4590, 7, 92, 2, 2, 4590, 4593, 7, 190, 2, 2, 4591, 4594, 7, 591, 2, 2, 4592, 4594, 5, 694, 348, 2, 4593, 4591, 3, 2, 2, 2, 4593, 4592, 3, 2, 2, 2, 4594, 4620, 3, 2, 2, 2, 4595, 4601, 7, 468, 2, 2, 4596, 4602, 7, 591, 2, 2, 4597, 4598, 7, 587, 2, 2, 4598, 4599, 5, 694, 348, 2, 4599, 4600, 7, 588, 2, 2, 4600, 4602, 3, 2, 2, 2, 4601, 4596, 3, 2, 2, 2, 4601, 4597, 3, 2, 2, 2, 4602, 4620, 3, 2, 2, 2, 4603, 4604, 7, 92, 2, 2, 4604, 4605, 7, 416, 2, 2, 4605, 4606, 7, 417, 2, 2, 4606, 4620, 5, 694, 348, 2, 4607, 4608, 7, 466, 2, 2, 4608, 4609, 7, 587, 2, 2, 4609, 4610, 5, 694, 348, 2, 4610, 4611, 7, 588, 2, 2, 4611, 4620, 3, 2, 2, 2, 4612, 4613, 7, 467, 2, 2, 4613, 4614, 7, 587, 2, 2, 4614, 4615, 5, 694, 348, 2, 4615, 4616, 7, 588, 2, 2, 4616, 4620, 3, 2, 2, 2, 4617, 4618, 7, 76, 2, 2, 4618, 4620, 7, 615, 2, 2, 4619, 4560, 3, 2, 2, 2, 4619, 4563, 3, 2, 2, 2, 4619, 4567, 3, 2, 2, 2, 4619, 4571, 3, 2, 2, 2, 4619, 4576, 3, 2, 2, 2, 4619, 4581, 3, 2, 2, 2, 4619, 4585, 3, 2, 2, 2, 4619, 4587, 3, 2, 2, 2, 4619, 4589, 3, 2, 2, 2, 4619, 4595, 3, 2, 2, 2, 4619, 4603, 3, 2, 2, 2, 4619, 4607, 3, 2, 2, 2, 4619, 4612, 3, 2, 2, 2, 4619, 4617, 3, 2, 2, 2, 4620, 405, 3, 2, 2, 2, 4621, 4622, 7, 421, 2, 2, 4622, 4624, 7, 204, 2, 2, 4623, 4621, 3, 2, 2, 2, 4623, 4624, 3, 2, 2, 2, 4624, 4626, 3, 2, 2, 2, 4625, 4627, 9, 54, 2, 2, 4626, 4625, 3, 2, 2, 2, 4626, 4627, 3, 2, 2, 2, 4627, 4629, 3, 2, 2, 2, 4628, 4630, 7, 195, 2, 2, 4629, 4628, 3, 2, 2, 2, 4629, 4630, 3, 2, 2, 2, 4630, 4632, 3, 2, 2, 2, 4631, 4633, 7, 140, 2, 2, 4632, 4631, 3, 2, 2, 2, 4632, 4633, 3, 2, 2, 2, 4633, 4634, 3, 2, 2, 2, 4634, 4636, 7, 282, 2, 2, 4635, 4637, 5, 410, 206, 2, 4636, 4635, 3, 2, 2, 2, 4636, 4637, 3, 2, 2, 2, 4637, 4638, 3, 2, 2, 2, 4638, 4640, 5, 618, 310, 2, 4639, 4641, 5, 412, 207, 2, 4640, 4639, 3, 2, 2, 2, 4640, 4641, 3, 2, 2, 2, 4641, 4644, 3, 2, 2, 2, 4642, 4643, 7, 439, 2, 2, 4643, 4645, 5, 528, 265, 2, 4644, 4642, 3, 2, 2, 2, 4644, 4645, 3, 2, 2, 2, 4645, 4648, 3, 2, 2, 2, 4646, 4647, 7, 444, 2, 2, 4647, 4649, 5, 476, 239, 2, 4648, 4646, 3, 2, 2, 2, 4648, 4649, 3, 2, 2, 2, 4649, 4651, 3, 2, 2, 2, 4650, 4652, 5, 488, 245, 2, 4651, 4650, 3, 2, 2, 2, 4651, 4652, 3, 2, 2, 2, 4652, 4653, 3, 2, 2, 2, 4653, 4654, 7, 374, 2, 2, 4654, 4656, 5, 624, 313, 2, 4655, 4657, 5, 414, 208, 2, 4656, 4655, 3, 2, 2, 2, 4656, 4657, 3, 2, 2, 2, 4657, 4663, 3, 2, 2, 2, 4658, 4660, 7, 444, 2, 2, 4659, 4661, 7, 152, 2, 2, 4660, 4659, 3, 2, 2, 2, 4660, 4661, 3, 2, 2, 2, 4661, 4662, 3, 2, 2, 2, 4662, 4664, 7, 54, 2, 2, 4663, 4658, 3, 2, 2, 2, 4663, 4664, 3, 2, 2, 2, 4664, 407, 3, 2, 2, 2, 4665, 4666, 7, 105, 2, 2, 4666, 4667, 7, 304, 2, 2, 4667, 409, 3, 2, 2, 2, 4668, 4669, 7, 105, 2, 2, 4669, 4670, 7, 416, 2, 2, 4670, 4671, 7, 304, 2, 2, 4671, 411, 3, 2, 2, 2, 4672, 4673, 7, 587, 2, 2, 4673, 4678, 5, 528, 265, 2, 4674, 4675, 7, 581, 2, 2, 4675, 4677, 5, 528, 265, 2, 4676, 4674, 3, 2, 2, 2, 4677, 4680, 3, 2, 2, 2, 4678, 4676, 3, 2, 2, 2, 4678, 4679, 3, 2, 2, 2, 4679, 4681, 3, 2, 2, 2, 4680, 4678, 3, 2, 2, 2, 4681, 4682, 7, 588, 2, 2, 4682, 413, 3, 2, 2, 2, 4683, 4685, 7, 444, 2, 2, 4684, 4686, 9, 62, 2, 2, 4685, 4684, 3, 2, 2, 2, 4685, 4686, 3, 2, 2, 2, 4686, 4687, 3, 2, 2, 2, 4687, 4688, 7, 380, 2, 2, 4688, 4689, 7, 163, 2, 2, 4689, 415, 3, 2, 2, 2, 4690, 4692, 9, 63, 2, 2, 4691, 4690, 3, 2, 2, 2, 4691, 4692, 3, 2, 2, 2, 4692, 4693, 3, 2, 2, 2, 4693, 4696, 9, 54, 2, 2, 4694, 4696, 7, 272, 2, 2, 4695, 4691, 3, 2, 2, 2, 4695, 4694, 3, 2, 2, 2, 4695, 4696, 3, 2, 2, 2, 4696, 4697, 3, 2, 2, 2, 4697, 4699, 7, 431, 2, 2, 4698, 4700, 5, 410, 206, 2, 4699, 4698, 3, 2, 2, 2, 4699, 4700, 3, 2, 2, 2, 4700, 4701, 3, 2, 2, 2, 4701, 4702, 5, 618, 310, 2, 4702, 4704, 5, 422, 212, 2, 4703, 4705, 5, 436, 219, 2, 4704, 4703, 3, 2, 2, 2, 4704, 4705, 3, 2, 2, 2, 4705, 4708, 3, 2, 2, 2, 4706, 4707, 7, 439, 2, 2, 4707, 4709, 5, 528, 265, 2, 4708, 4706, 3, 2, 2, 2, 4708, 4709, 3, 2, 2, 2, 4709, 4711, 3, 2, 2, 2, 4710, 4712, 5, 484, 243, 2, 4711, 4710, 3, 2, 2, 2, 4711, 4712, 3, 2, 2, 2, 4712, 4714, 3, 2, 2, 2, 4713, 4715, 5, 486, 244, 2, 4714, 4713, 3, 2, 2, 2, 4714, 4715, 3, 2, 2, 2, 4715, 4717, 3, 2, 2, 2, 4716, 4718, 5, 488, 245, 2, 4717, 4716, 3, 2, 2, 2, 4717, 4718, 3, 2, 2, 2, 4718, 417, 3, 2, 2, 2, 4719, 4721, 9, 63, 2, 2, 4720, 4719, 3, 2, 2, 2, 4720, 4721, 3, 2, 2, 2, 4721, 4722, 3, 2, 2, 2, 4722, 4725, 9, 54, 2, 2, 4723, 4725, 7, 272, 2, 2, 4724, 4720, 3, 2, 2, 2, 4724, 4723, 3, 2, 2, 2, 4724, 4725, 3, 2, 2, 2, 4725, 4726, 3, 2, 2, 2, 4726, 4728, 7, 431, 2, 2, 4727, 4729, 5, 410, 206, 2, 4728, 4727, 3, 2, 2, 2, 4728, 4729, 3, 2, 2, 2, 4729, 4730, 3, 2, 2, 2, 4730, 4732, 5, 618, 310, 2, 4731, 4733, 5, 472, 237, 2, 4732, 4731, 3, 2, 2, 2, 4732, 4733, 3, 2, 2, 2, 4733, 4736, 3, 2, 2, 2, 4734, 4735, 7, 439, 2, 2, 4735, 4737, 5, 528, 265, 2, 4736, 4734, 3, 2, 2, 2, 4736, 4737, 3, 2, 2, 2, 4737, 4739, 3, 2, 2, 2, 4738, 4740, 5, 484, 243, 2, 4739, 4738, 3, 2, 2, 2, 4739, 4740, 3, 2, 2, 2, 4740, 4742, 3, 2, 2, 2, 4741, 4743, 5, 486, 244, 2, 4742, 4741, 3, 2, 2, 2, 4742, 4743, 3, 2, 2, 2, 4743, 4745, 3, 2, 2, 2, 4744, 4746, 5, 488, 245, 2, 4745, 4744, 3, 2, 2, 2, 4745, 4746, 3, 2, 2, 2, 4746, 4747, 3, 2, 2, 2, 4747, 4751, 7, 374, 2, 2, 4748, 4752, 5, 624, 313, 2, 4749, 4750, 7, 84, 2, 2, 4750, 4752, 5, 582, 292, 2, 4751, 4748, 3, 2, 2, 2, 4751, 4749, 3, 2, 2, 2, 4752, 4758, 3, 2, 2, 2, 4753, 4755, 7, 444, 2, 2, 4754, 4756, 7, 152, 2, 2, 4755, 4754, 3, 2, 2, 2, 4755, 4756, 3, 2, 2, 2, 4756, 4757, 3, 2, 2, 2, 4757, 4759, 7, 54, 2, 2, 4758, 4753, 3, 2, 2, 2, 4758, 4759, 3, 2, 2, 2, 4759, 419, 3, 2, 2, 2, 4760, 4761, 7, 402, 2, 2, 4761, 4763, 7, 431, 2, 2, 4762, 4764, 5, 410, 206, 2, 4763, 4762, 3, 2, 2, 2, 4763, 4764, 3, 2, 2, 2, 4764, 4765, 3, 2, 2, 2, 4765, 4768, 5, 618, 310, 2, 4766, 4769, 5, 432, 217, 2, 4767, 4769, 5, 424, 213, 2, 4768, 4766, 3, 2, 2, 2, 4768, 4767, 3, 2, 2, 2, 4769, 4770, 3, 2, 2, 2, 4770, 4771, 5, 442, 222, 2, 4771, 421, 3, 2, 2, 2, 4772, 4776, 5, 432, 217, 2, 4773, 4776, 5, 434, 218, 2, 4774, 4776, 5, 424, 213, 2, 4775, 4772, 3, 2, 2, 2, 4775, 4773, 3, 2, 2, 2, 4775, 4774, 3, 2, 2, 2, 4776, 423, 3, 2, 2, 2, 4777, 4778, 7, 174, 2, 2, 4778, 4779, 7, 158, 2, 2, 4779, 4781, 5, 618, 310, 2, 4780, 4782, 5, 450, 226, 2, 4781, 4780, 3, 2, 2, 2, 4781, 4782, 3, 2, 2, 2, 4782, 4783, 3, 2, 2, 2, 4783, 4784, 5, 426, 214, 2, 4784, 425, 3, 2, 2, 2, 4785, 4786, 7, 401, 2, 2, 4786, 4787, 7, 332, 2, 2, 4787, 4790, 5, 428, 215, 2, 4788, 4790, 7, 391, 2, 2, 4789, 4785, 3, 2, 2, 2, 4789, 4788, 3, 2, 2, 2, 4790, 427, 3, 2, 2, 2, 4791, 4792, 7, 407, 2, 2, 4792, 4793, 7, 587, 2, 2, 4793, 4798, 5, 560, 281, 2, 4794, 4795, 7, 581, 2, 2, 4795, 4797, 5, 560, 281, 2, 4796, 4794, 3, 2, 2, 2, 4797, 4800, 3, 2, 2, 2, 4798, 4796, 3, 2, 2, 2, 4798, 4799, 3, 2, 2, 2, 4799, 4801, 3, 2, 2, 2, 4800, 4798, 3, 2, 2, 2, 4801, 4802, 7, 588, 2, 2, 4802, 4817, 3, 2, 2, 2, 4803, 4804, 7, 403, 2, 2, 4804, 4805, 5, 430, 216, 2, 4805, 4806, 7, 433, 2, 2, 4806, 4807, 5, 430, 216, 2, 4807, 4817, 3, 2, 2, 2, 4808, 4809, 7, 444, 2, 2, 4809, 4810, 7, 587, 2, 2, 4810, 4811, 7, 495, 2, 2, 4811, 4812, 7, 610, 2, 2, 4812, 4813, 7, 581, 2, 2, 4813, 4814, 7, 517, 2, 2, 4814, 4815, 7, 610, 2, 2, 4815, 4817, 7, 588, 2, 2, 4816, 4791, 3, 2, 2, 2, 4816, 4803, 3, 2, 2, 2, 4816, 4808, 3, 2, 2, 2, 4817, 429, 3, 2, 2, 2, 4818, 4819, 7, 587, 2, 2, 4819, 4824, 5, 560, 281, 2, 4820, 4821, 7, 581, 2, 2, 4821, 4823, 5, 560, 281, 2, 4822, 4820, 3, 2, 2, 2, 4823, 4826, 3, 2, 2, 2, 4824, 4822, 3, 2, 2, 2, 4824, 4825, 3, 2, 2, 2, 4825, 4827, 3, 2, 2, 2, 4826, 4824, 3, 2, 2, 2, 4827, 4828, 7, 588, 2, 2, 4828, 431, 3, 2, 2, 2, 4829, 4838, 7, 587, 2, 2, 4830, 4835, 5, 452, 227, 2, 4831, 4832, 7, 581, 2, 2, 4832, 4834, 5, 452, 227, 2, 4833, 4831, 3, 2, 2, 2, 4834, 4837, 3, 2, 2, 2, 4835, 4833, 3, 2, 2, 2, 4835, 4836, 3, 2, 2, 2, 4836, 4839, 3, 2, 2, 2, 4837, 4835, 3, 2, 2, 2, 4838, 4830, 3, 2, 2, 2, 4838, 4839, 3, 2, 2, 2, 4839, 4840, 3, 2, 2, 2, 4840, 4843, 7, 588, 2, 2, 4841, 4842, 7, 116, 2, 2, 4842, 4844, 5, 472, 237, 2, 4843, 4841, 3, 2, 2, 2, 4843, 4844, 3, 2, 2, 2, 4844, 433, 3, 2, 2, 2, 4845, 4846, 7, 158, 2, 2, 4846, 4848, 5, 548, 275, 2, 4847, 4849, 5, 450, 226, 2, 4848, 4847, 3, 2, 2, 2, 4848, 4849, 3, 2, 2, 2, 4849, 435, 3, 2, 2, 2, 4850, 4851, 7, 174, 2, 2, 4851, 4852, 7, 22, 2, 2, 4852, 4853, 5, 438, 220, 2, 4853, 437, 3, 2, 2, 2, 4854, 4855, 9, 64, 2, 2, 4855, 4856, 7, 587, 2, 2, 4856, 4861, 5, 440, 221, 2, 4857, 4858, 7, 581, 2, 2, 4858, 4860, 5, 440, 221, 2, 4859, 4857, 3, 2, 2, 2, 4860, 4863, 3, 2, 2, 2, 4861, 4859, 3, 2, 2, 2, 4861, 4862, 3, 2, 2, 2, 4862, 4864, 3, 2, 2, 2, 4863, 4861, 3, 2, 2, 2, 4864, 4865, 7, 588, 2, 2, 4865, 439, 3, 2, 2, 2, 4866, 4868, 5, 560, 281, 2, 4867, 4869, 5, 528, 265, 2, 4868, 4867, 3, 2, 2, 2, 4868, 4869, 3, 2, 2, 2, 4869, 441, 3, 2, 2, 2, 4870, 4871, 7, 228, 2, 2, 4871, 4873, 5, 528, 265, 2, 4872, 4874, 5, 444, 223, 2, 4873, 4872, 3, 2, 2, 2, 4873, 4874, 3, 2, 2, 2, 4874, 443, 3, 2, 2, 2, 4875, 4876, 7, 164, 2, 2, 4876, 4877, 7, 587, 2, 2, 4877, 4882, 5, 446, 224, 2, 4878, 4879, 7, 581, 2, 2, 4879, 4881, 5, 446, 224, 2, 4880, 4878, 3, 2, 2, 2, 4881, 4884, 3, 2, 2, 2, 4882, 4880, 3, 2, 2, 2, 4882, 4883, 3, 2, 2, 2, 4883, 4885, 3, 2, 2, 2, 4884, 4882, 3, 2, 2, 2, 4885, 4886, 7, 588, 2, 2, 4886, 445, 3, 2, 2, 2, 4887, 4889, 9, 60, 2, 2, 4888, 4887, 3, 2, 2, 2, 4888, 4889, 3, 2, 2, 2, 4889, 4890, 3, 2, 2, 2, 4890, 4892, 5, 448, 225, 2, 4891, 4893, 5, 326, 164, 2, 4892, 4891, 3, 2, 2, 2, 4892, 4893, 3, 2, 2, 2, 4893, 447, 3, 2, 2, 2, 4894, 4897, 5, 528, 265, 2, 4895, 4897, 7, 438, 2, 2, 4896, 4894, 3, 2, 2, 2, 4896, 4895, 3, 2, 2, 2, 4897, 449, 3, 2, 2, 2, 4898, 4899, 7, 587, 2, 2, 4899, 4904, 5, 454, 228, 2, 4900, 4901, 7, 581, 2, 2, 4901, 4903, 5, 454, 228, 2, 4902, 4900, 3, 2, 2, 2, 4903, 4906, 3, 2, 2, 2, 4904, 4902, 3, 2, 2, 2, 4904, 4905, 3, 2, 2, 2, 4905, 4907, 3, 2, 2, 2, 4906, 4904, 3, 2, 2, 2, 4907, 4908, 7, 588, 2, 2, 4908, 451, 3, 2, 2, 2, 4909, 4920, 5, 456, 229, 2, 4910, 4920, 5, 460, 231, 2, 4911, 4912, 7, 359, 2, 2, 4912, 4916, 5, 618, 310, 2, 4913, 4915, 5, 458, 230, 2, 4914, 4913, 3, 2, 2, 2, 4915, 4918, 3, 2, 2, 2, 4916, 4914, 3, 2, 2, 2, 4916, 4917, 3, 2, 2, 2, 4917, 4920, 3, 2, 2, 2, 4918, 4916, 3, 2, 2, 2, 4919, 4909, 3, 2, 2, 2, 4919, 4910, 3, 2, 2, 2, 4919, 4911, 3, 2, 2, 2, 4920, 453, 3, 2, 2, 2, 4921, 4924, 5, 528, 265, 2, 4922, 4923, 7, 444, 2, 2, 4923, 4925, 7, 164, 2, 2, 4924, 4922, 3, 2, 2, 2, 4924, 4925, 3, 2, 2, 2, 4925, 4929, 3, 2, 2, 2, 4926, 4928, 5, 460, 231, 2, 4927, 4926, 3, 2, 2, 2, 4928, 4931, 3, 2, 2, 2, 4929, 4927, 3, 2, 2, 2, 4929, 4930, 3, 2, 2, 2, 4930, 4934, 3, 2, 2, 2, 4931, 4929, 3, 2, 2, 2, 4932, 4934, 5, 460, 231, 2, 4933, 4921, 3, 2, 2, 2, 4933, 4932, 3, 2, 2, 2, 4934, 455, 3, 2, 2, 2, 4935, 4936, 5, 528, 265, 2, 4936, 4938, 5, 548, 275, 2, 4937, 4939, 5, 444, 223, 2, 4938, 4937, 3, 2, 2, 2, 4938, 4939, 3, 2, 2, 2, 4939, 4941, 3, 2, 2, 2, 4940, 4942, 5, 506, 254, 2, 4941, 4940, 3, 2, 2, 2, 4941, 4942, 3, 2, 2, 2, 4942, 4946, 3, 2, 2, 2, 4943, 4945, 5, 460, 231, 2, 4944, 4943, 3, 2, 2, 2, 4945, 4948, 3, 2, 2, 2, 4946, 4944, 3, 2, 2, 2, 4946, 4947, 3, 2, 2, 2, 4947, 457, 3, 2, 2, 2, 4948, 4946, 3, 2, 2, 2, 4949, 4950, 9, 65, 2, 2, 4950, 4951, 9, 66, 2, 2, 4951, 459, 3, 2, 2, 2, 4952, 4953, 7, 383, 2, 2, 4953, 4955, 5, 528, 265, 2, 4954, 4952, 3, 2, 2, 2, 4954, 4955, 3, 2, 2, 2, 4955, 4956, 3, 2, 2, 2, 4956, 4958, 5, 462, 232, 2, 4957, 4959, 5, 100, 51, 2, 4958, 4957, 3, 2, 2, 2, 4958, 4959, 3, 2, 2, 2, 4959, 4961, 3, 2, 2, 2, 4960, 4962, 5, 102, 52, 2, 4961, 4960, 3, 2, 2, 2, 4961, 4962, 3, 2, 2, 2, 4962, 461, 3, 2, 2, 2, 4963, 4966, 7, 81, 2, 2, 4964, 4965, 7, 439, 2, 2, 4965, 4967, 5, 528, 265, 2, 4966, 4964, 3, 2, 2, 2, 4966, 4967, 3, 2, 2, 2, 4967, 4968, 3, 2, 2, 2, 4968, 4969, 7, 587, 2, 2, 4969, 4970, 5, 668, 335, 2, 4970, 4971, 7, 444, 2, 2, 4971, 4979, 5, 464, 233, 2, 4972, 4973, 7, 581, 2, 2, 4973, 4974, 5, 668, 335, 2, 4974, 4975, 7, 444, 2, 2, 4975, 4976, 5, 464, 233, 2, 4976, 4978, 3, 2, 2, 2, 4977, 4972, 3, 2, 2, 2, 4978, 4981, 3, 2, 2, 2, 4979, 4977, 3, 2, 2, 2, 4979, 4980, 3, 2, 2, 2, 4980, 4982, 3, 2, 2, 2, 4981, 4979, 3, 2, 2, 2, 4982, 4983, 7, 588, 2, 2, 4983, 4986, 5, 470, 236, 2, 4984, 4985, 7, 442, 2, 2, 4985, 4987, 5, 560, 281, 2, 4986, 4984, 3, 2, 2, 2, 4986, 4987, 3, 2, 2, 2, 4987, 5041, 3, 2, 2, 2, 4988, 4989, 7, 402, 2, 2, 4989, 4990, 7, 124, 2, 2, 4990, 4992, 5, 472, 237, 2, 4991, 4988, 3, 2, 2, 2, 4991, 4992, 3, 2, 2, 2, 4992, 4993, 3, 2, 2, 2, 4993, 4994, 7, 425, 2, 2, 4994, 4996, 5, 618, 310, 2, 4995, 4997, 5, 472, 237, 2, 4996, 4995, 3, 2, 2, 2, 4996, 4997, 3, 2, 2, 2, 4997, 5005, 3, 2, 2, 2, 4998, 4999, 7, 139, 2, 2, 4999, 5004, 9, 67, 2, 2, 5000, 5001, 7, 419, 2, 2, 5001, 5002, 9, 68, 2, 2, 5002, 5004, 5, 490, 246, 2, 5003, 4998, 3, 2, 2, 2, 5003, 5000, 3, 2, 2, 2, 5004, 5007, 3, 2, 2, 2, 5005, 5003, 3, 2, 2, 2, 5005, 5006, 3, 2, 2, 2, 5006, 5041, 3, 2, 2, 2, 5007, 5005, 3, 2, 2, 2, 5008, 5009, 7, 380, 2, 2, 5009, 5010, 7, 587, 2, 2, 5010, 5011, 5, 560, 281, 2, 5011, 5014, 7, 588, 2, 2, 5012, 5013, 7, 152, 2, 2, 5013, 5015, 7, 115, 2, 2, 5014, 5012, 3, 2, 2, 2, 5014, 5015, 3, 2, 2, 2, 5015, 5041, 3, 2, 2, 2, 5016, 5018, 7, 416, 2, 2, 5017, 5016, 3, 2, 2, 2, 5017, 5018, 3, 2, 2, 2, 5018, 5019, 3, 2, 2, 2, 5019, 5041, 7, 417, 2, 2, 5020, 5024, 7, 437, 2, 2, 5021, 5022, 7, 424, 2, 2, 5022, 5024, 7, 124, 2, 2, 5023, 5020, 3, 2, 2, 2, 5023, 5021, 3, 2, 2, 2, 5024, 5026, 3, 2, 2, 2, 5025, 5027, 5, 472, 237, 2, 5026, 5025, 3, 2, 2, 2, 5026, 5027, 3, 2, 2, 2, 5027, 5028, 3, 2, 2, 2, 5028, 5041, 5, 470, 236, 2, 5029, 5030, 7, 391, 2, 2, 5030, 5041, 5, 560, 281, 2, 5031, 5041, 5, 90, 46, 2, 5032, 5033, 7, 96, 2, 2, 5033, 5034, 7, 13, 2, 2, 5034, 5035, 7, 374, 2, 2, 5035, 5036, 7, 587, 2, 2, 5036, 5037, 5, 560, 281, 2, 5037, 5038, 7, 588, 2, 2, 5038, 5039, 7, 246, 2, 2, 5039, 5041, 3, 2, 2, 2, 5040, 4963, 3, 2, 2, 2, 5040, 4991, 3, 2, 2, 2, 5040, 5008, 3, 2, 2, 2, 5040, 5017, 3, 2, 2, 2, 5040, 5023, 3, 2, 2, 2, 5040, 5029, 3, 2, 2, 2, 5040, 5031, 3, 2, 2, 2, 5040, 5032, 3, 2, 2, 2, 5041, 463, 3, 2, 2, 2, 5042, 5056, 5, 564, 283, 2, 5043, 5056, 7, 578, 2, 2, 5044, 5056, 7, 582, 2, 2, 5045, 5056, 7, 583, 2, 2, 5046, 5056, 7, 584, 2, 2, 5047, 5056, 7, 585, 2, 2, 5048, 5056, 7, 586, 2, 2, 5049, 5056, 7, 589, 2, 2, 5050, 5056, 7, 590, 2, 2, 5051, 5056, 7, 591, 2, 2, 5052, 5056, 7, 592, 2, 2, 5053, 5056, 7, 593, 2, 2, 5054, 5056, 7, 594, 2, 2, 5055, 5042, 3, 2, 2, 2, 5055, 5043, 3, 2, 2, 2, 5055, 5044, 3, 2, 2, 2, 5055, 5045, 3, 2, 2, 2, 5055, 5046, 3, 2, 2, 2, 5055, 5047, 3, 2, 2, 2, 5055, 5048, 3, 2, 2, 2, 5055, 5049, 3, 2, 2, 2, 5055, 5050, 3, 2, 2, 2, 5055, 5051, 3, 2, 2, 2, 5055, 5052, 3, 2, 2, 2, 5055, 5053, 3, 2, 2, 2, 5055, 5054, 3, 2, 2, 2, 5056, 465, 3, 2, 2, 2, 5057, 5071, 5, 468, 235, 2, 5058, 5071, 7, 578, 2, 2, 5059, 5071, 7, 582, 2, 2, 5060, 5071, 7, 583, 2, 2, 5061, 5071, 7, 584, 2, 2, 5062, 5071, 7, 585, 2, 2, 5063, 5071, 7, 586, 2, 2, 5064, 5071, 7, 589, 2, 2, 5065, 5071, 7, 590, 2, 2, 5066, 5071, 7, 591, 2, 2, 5067, 5071, 7, 592, 2, 2, 5068, 5071, 7, 593, 2, 2, 5069, 5071, 7, 594, 2, 2, 5070, 5057, 3, 2, 2, 2, 5070, 5058, 3, 2, 2, 2, 5070, 5059, 3, 2, 2, 2, 5070, 5060, 3, 2, 2, 2, 5070, 5061, 3, 2, 2, 2, 5070, 5062, 3, 2, 2, 2, 5070, 5063, 3, 2, 2, 2, 5070, 5064, 3, 2, 2, 2, 5070, 5065, 3, 2, 2, 2, 5070, 5066, 3, 2, 2, 2, 5070, 5067, 3, 2, 2, 2, 5070, 5068, 3, 2, 2, 2, 5070, 5069, 3, 2, 2, 2, 5071, 467, 3, 2, 2, 2, 5072, 5073, 9, 69, 2, 2, 5073, 469, 3, 2, 2, 2, 5074, 5076, 5, 150, 76, 2, 5075, 5074, 3, 2, 2, 2, 5075, 5076, 3, 2, 2, 2, 5076, 5078, 3, 2, 2, 2, 5077, 5079, 5, 482, 242, 2, 5078, 5077, 3, 2, 2, 2, 5078, 5079, 3, 2, 2, 2, 5079, 5086, 3, 2, 2, 2, 5080, 5081, 7, 439, 2, 2, 5081, 5084, 7, 113, 2, 2, 5082, 5085, 5, 488, 245, 2, 5083, 5085, 5, 618, 310, 2, 5084, 5082, 3, 2, 2, 2, 5084, 5083, 3, 2, 2, 2, 5085, 5087, 3, 2, 2, 2, 5086, 5080, 3, 2, 2, 2, 5086, 5087, 3, 2, 2, 2, 5087, 471, 3, 2, 2, 2, 5088, 5089, 7, 587, 2, 2, 5089, 5090, 5, 474, 238, 2, 5090, 5091, 7, 588, 2, 2, 5091, 473, 3, 2, 2, 2, 5092, 5097, 5, 618, 310, 2, 5093, 5094, 7, 581, 2, 2, 5094, 5096, 5, 618, 310, 2, 5095, 5093, 3, 2, 2, 2, 5096, 5099, 3, 2, 2, 2, 5097, 5095, 3, 2, 2, 2, 5097, 5098, 3, 2, 2, 2, 5098, 475, 3, 2, 2, 2, 5099, 5097, 3, 2, 2, 2, 5100, 5101, 7, 587, 2, 2, 5101, 5106, 5, 478, 240, 2, 5102, 5103, 7, 581, 2, 2, 5103, 5105, 5, 478, 240, 2, 5104, 5102, 3, 2, 2, 2, 5105, 5108, 3, 2, 2, 2, 5106, 5104, 3, 2, 2, 2, 5106, 5107, 3, 2, 2, 2, 5107, 5109, 3, 2, 2, 2, 5108, 5106, 3, 2, 2, 2, 5109, 5110, 7, 588, 2, 2, 5110, 477, 3, 2, 2, 2, 5111, 5114, 5, 480, 241, 2, 5112, 5113, 7, 578, 2, 2, 5113, 5115, 5, 560, 281, 2, 5114, 5112, 3, 2, 2, 2, 5114, 5115, 3, 2, 2, 2, 5115, 479, 3, 2, 2, 2, 5116, 5119, 5, 532, 267, 2, 5117, 5118, 7, 595, 2, 2, 5118, 5120, 5, 532, 267, 2, 5119, 5117, 3, 2, 2, 2, 5119, 5120, 3, 2, 2, 2, 5120, 481, 3, 2, 2, 2, 5121, 5122, 7, 444, 2, 2, 5122, 5123, 5, 476, 239, 2, 5123, 483, 3, 2, 2, 2, 5124, 5130, 5, 482, 242, 2, 5125, 5126, 7, 444, 2, 2, 5126, 5130, 7, 160, 2, 2, 5127, 5128, 7, 287, 2, 2, 5128, 5130, 7, 160, 2, 2, 5129, 5124, 3, 2, 2, 2, 5129, 5125, 3, 2, 2, 2, 5129, 5127, 3, 2, 2, 2, 5130, 485, 3, 2, 2, 2, 5131, 5132, 7, 419, 2, 2, 5132, 5138, 7, 38, 2, 2, 5133, 5134, 7, 182, 2, 2, 5134, 5139, 7, 216, 2, 2, 5135, 5136, 7, 62, 2, 2, 5136, 5139, 7, 216, 2, 2, 5137, 5139, 7, 73, 2, 2, 5138, 5133, 3, 2, 2, 2, 5138, 5135, 3, 2, 2, 2, 5138, 5137, 3, 2, 2, 2, 5139, 487, 3, 2, 2, 2, 5140, 5141, 7, 254, 2, 2, 5141, 5142, 5, 528, 265, 2, 5142, 489, 3, 2, 2, 2, 5143, 5149, 5, 504, 253, 2, 5144, 5145, 7, 230, 2, 2, 5145, 5149, 9, 70, 2, 2, 5146, 5147, 7, 152, 2, 2, 5147, 5149, 7, 6, 2, 2, 5148, 5143, 3, 2, 2, 2, 5148, 5144, 3, 2, 2, 2, 5148, 5146, 3, 2, 2, 2, 5149, 491, 3, 2, 2, 2, 5150, 5151, 7, 170, 2, 2, 5151, 5155, 7, 433, 2, 2, 5152, 5156, 5, 528, 265, 2, 5153, 5156, 7, 390, 2, 2, 5154, 5156, 7, 428, 2, 2, 5155, 5152, 3, 2, 2, 2, 5155, 5153, 3, 2, 2, 2, 5155, 5154, 3, 2, 2, 2, 5156, 493, 3, 2, 2, 2, 5157, 5158, 7, 202, 2, 2, 5158, 5159, 7, 433, 2, 2, 5159, 5160, 5, 528, 265, 2, 5160, 495, 3, 2, 2, 2, 5161, 5162, 7, 230, 2, 2, 5162, 5163, 7, 219, 2, 2, 5163, 5164, 5, 528, 265, 2, 5164, 497, 3, 2, 2, 2, 5165, 5177, 7, 427, 2, 2, 5166, 5177, 7, 120, 2, 2, 5167, 5177, 7, 274, 2, 2, 5168, 5177, 7, 62, 2, 2, 5169, 5177, 7, 263, 2, 2, 5170, 5177, 7, 425, 2, 2, 5171, 5177, 7, 262, 2, 2, 5172, 5174, 7, 368, 2, 2, 5173, 5175, 7, 184, 2, 2, 5174, 5173, 3, 2, 2, 2, 5174, 5175, 3, 2, 2, 2, 5175, 5177, 3, 2, 2, 2, 5176, 5165, 3, 2, 2, 2, 5176, 5166, 3, 2, 2, 2, 5176, 5167, 3, 2, 2, 2, 5176, 5168, 3, 2, 2, 2, 5176, 5169, 3, 2, 2, 2, 5176, 5170, 3, 2, 2, 2, 5176, 5171, 3, 2, 2, 2, 5176, 5172, 3, 2, 2, 2, 5177, 499, 3, 2, 2, 2, 5178, 5179, 9, 71, 2, 2, 5179, 501, 3, 2, 2, 2, 5180, 5181, 7, 174, 2, 2, 5181, 5182, 7, 22, 2, 2, 5182, 5187, 5, 560, 281, 2, 5183, 5184, 7, 581, 2, 2, 5184, 5186, 5, 560, 281, 2, 5185, 5183, 3, 2, 2, 2, 5186, 5189, 3, 2, 2, 2, 5187, 5185, 3, 2, 2, 2, 5187, 5188, 3, 2, 2, 2, 5188, 503, 3, 2, 2, 2, 5189, 5187, 3, 2, 2, 2, 5190, 5191, 9, 72, 2, 2, 5191, 505, 3, 2, 2, 2, 5192, 5193, 7, 381, 2, 2, 5193, 5194, 5, 618, 310, 2, 5194, 507, 3, 2, 2, 2, 5195, 5198, 5, 528, 265, 2, 5196, 5198, 5, 510, 256, 2, 5197, 5195, 3, 2, 2, 2, 5197, 5196, 3, 2, 2, 2, 5198, 5200, 3, 2, 2, 2, 5199, 5201, 5, 512, 257, 2, 5200, 5199, 3, 2, 2, 2, 5200, 5201, 3, 2, 2, 2, 5201, 509, 3, 2, 2, 2, 5202, 5203, 7, 612, 2, 2, 5203, 511, 3, 2, 2, 2, 5204, 5206, 5, 514, 258, 2, 5205, 5204, 3, 2, 2, 2, 5206, 5207, 3, 2, 2, 2, 5207, 5205, 3, 2, 2, 2, 5207, 5208, 3, 2, 2, 2, 5208, 5218, 3, 2, 2, 2, 5209, 5211, 5, 514, 258, 2, 5210, 5209, 3, 2, 2, 2, 5211, 5214, 3, 2, 2, 2, 5212, 5210, 3, 2, 2, 2, 5212, 5213, 3, 2, 2, 2, 5213, 5215, 3, 2, 2, 2, 5214, 5212, 3, 2, 2, 2, 5215, 5216, 7, 595, 2, 2, 5216, 5218, 7, 591, 2, 2, 5217, 5205, 3, 2, 2, 2, 5217, 5212, 3, 2, 2, 2, 5218, 513, 3, 2, 2, 2, 5219, 5220, 7, 595, 2, 2, 5220, 5235, 5, 532, 267, 2, 5221, 5222, 7, 599, 2, 2, 5222, 5223, 5, 560, 281, 2, 5223, 5224, 7, 600, 2, 2, 5224, 5235, 3, 2, 2, 2, 5225, 5227, 7, 599, 2, 2, 5226, 5228, 5, 560, 281, 2, 5227, 5226, 3, 2, 2, 2, 5227, 5228, 3, 2, 2, 2, 5228, 5229, 3, 2, 2, 2, 5229, 5231, 7, 579, 2, 2, 5230, 5232, 5, 560, 281, 2, 5231, 5230, 3, 2, 2, 2, 5231, 5232, 3, 2, 2, 2, 5232, 5233, 3, 2, 2, 2, 5233, 5235, 7, 600, 2, 2, 5234, 5219, 3, 2, 2, 2, 5234, 5221, 3, 2, 2, 2, 5234, 5225, 3, 2, 2, 2, 5235, 515, 3, 2, 2, 2, 5236, 5238, 9, 35, 2, 2, 5237, 5239, 5, 408, 205, 2, 5238, 5237, 3, 2, 2, 2, 5238, 5239, 3, 2, 2, 2, 5239, 5240, 3, 2, 2, 2, 5240, 5242, 5, 618, 310, 2, 5241, 5243, 5, 322, 162, 2, 5242, 5241, 3, 2, 2, 2, 5242, 5243, 3, 2, 2, 2, 5243, 5245, 3, 2, 2, 2, 5244, 5246, 5, 504, 253, 2, 5245, 5244, 3, 2, 2, 2, 5245, 5246, 3, 2, 2, 2, 5246, 517, 3, 2, 2, 2, 5247, 5249, 7, 262, 2, 2, 5248, 5250, 5, 408, 205, 2, 5249, 5248, 3, 2, 2, 2, 5249, 5250, 3, 2, 2, 2, 5250, 5251, 3, 2, 2, 2, 5251, 5252, 5, 528, 265, 2, 5252, 5253, 7, 419, 2, 2, 5253, 5255, 5, 618, 310, 2, 5254, 5256, 5, 504, 253, 2, 5255, 5254, 3, 2, 2, 2, 5255, 5256, 3, 2, 2, 2, 5256, 519, 3, 2, 2, 2, 5257, 5259, 7, 217, 2, 2, 5258, 5260, 5, 408, 205, 2, 5259, 5258, 3, 2, 2, 2, 5259, 5260, 3, 2, 2, 2, 5260, 5261, 3, 2, 2, 2, 5261, 5262, 5, 528, 265, 2, 5262, 5263, 7, 419, 2, 2, 5263, 5265, 5, 618, 310, 2, 5264, 5266, 5, 504, 253, 2, 5265, 5264, 3, 2, 2, 2, 5265, 5266, 3, 2, 2, 2, 5266, 521, 3, 2, 2, 2, 5267, 5268, 7, 5, 2, 2, 5268, 5310, 7, 142, 2, 2, 5269, 5310, 7, 347, 2, 2, 5270, 5310, 7, 46, 2, 2, 5271, 5310, 7, 55, 2, 2, 5272, 5310, 7, 71, 2, 2, 5273, 5274, 7, 80, 2, 2, 5274, 5310, 7, 262, 2, 2, 5275, 5310, 7, 86, 2, 2, 5276, 5310, 7, 405, 2, 2, 5277, 5279, 7, 402, 2, 2, 5278, 5277, 3, 2, 2, 2, 5278, 5279, 3, 2, 2, 2, 5279, 5280, 3, 2, 2, 2, 5280, 5310, 7, 431, 2, 2, 5281, 5282, 7, 402, 2, 2, 5282, 5283, 7, 54, 2, 2, 5283, 5310, 7, 289, 2, 2, 5284, 5286, 7, 113, 2, 2, 5285, 5287, 7, 348, 2, 2, 5286, 5285, 3, 2, 2, 2, 5286, 5287, 3, 2, 2, 2, 5287, 5310, 3, 2, 2, 2, 5288, 5290, 7, 140, 2, 2, 5289, 5288, 3, 2, 2, 2, 5289, 5290, 3, 2, 2, 2, 5290, 5291, 3, 2, 2, 2, 5291, 5310, 7, 282, 2, 2, 5292, 5294, 7, 185, 2, 2, 5293, 5292, 3, 2, 2, 2, 5293, 5294, 3, 2, 2, 2, 5294, 5295, 3, 2, 2, 2, 5295, 5310, 7, 126, 2, 2, 5296, 5310, 7, 189, 2, 2, 5297, 5310, 7, 211, 2, 2, 5298, 5310, 7, 219, 2, 2, 5299, 5310, 7, 225, 2, 2, 5300, 5310, 7, 228, 2, 2, 5301, 5310, 7, 242, 2, 2, 5302, 5310, 7, 249, 2, 2, 5303, 5310, 7, 254, 2, 2, 5304, 5310, 7, 265, 2, 2, 5305, 5306, 7, 258, 2, 2, 5306, 5307, 7, 222, 2, 2, 5307, 5310, 9, 32, 2, 2, 5308, 5310, 7, 438, 2, 2, 5309, 5267, 3, 2, 2, 2, 5309, 5269, 3, 2, 2, 2, 5309, 5270, 3, 2, 2, 2, 5309, 5271, 3, 2, 2, 2, 5309, 5272, 3, 2, 2, 2, 5309, 5273, 3, 2, 2, 2, 5309, 5275, 3, 2, 2, 2, 5309, 5276, 3, 2, 2, 2, 5309, 5278, 3, 2, 2, 2, 5309, 5281, 3, 2, 2, 2, 5309, 5284, 3, 2, 2, 2, 5309, 5289, 3, 2, 2, 2, 5309, 5293, 3, 2, 2, 2, 5309, 5296, 3, 2, 2, 2, 5309, 5297, 3, 2, 2, 2, 5309, 5298, 3, 2, 2, 2, 5309, 5299, 3, 2, 2, 2, 5309, 5300, 3, 2, 2, 2, 5309, 5301, 3, 2, 2, 2, 5309, 5302, 3, 2, 2, 2, 5309, 5303, 3, 2, 2, 2, 5309, 5304, 3, 2, 2, 2, 5309, 5305, 3, 2, 2, 2, 5309, 5308, 3, 2, 2, 2, 5310, 5311, 3, 2, 2, 2, 5311, 5312, 5, 524, 263, 2, 5312, 523, 3, 2, 2, 2, 5313, 5315, 5, 408, 205, 2, 5314, 5313, 3, 2, 2, 2, 5314, 5315, 3, 2, 2, 2, 5315, 5316, 3, 2, 2, 2, 5316, 5318, 5, 474, 238, 2, 5317, 5319, 5, 504, 253, 2, 5318, 5317, 3, 2, 2, 2, 5318, 5319, 3, 2, 2, 2, 5319, 525, 3, 2, 2, 2, 5320, 5324, 7, 613, 2, 2, 5321, 5324, 7, 614, 2, 2, 5322, 5324, 5, 542, 272, 2, 5323, 5320, 3, 2, 2, 2, 5323, 5321, 3, 2, 2, 2, 5323, 5322, 3, 2, 2, 2, 5324, 527, 3, 2, 2, 2, 5325, 5329, 5, 526, 264, 2, 5326, 5329, 5, 534, 268, 2, 5327, 5329, 5, 536, 269, 2, 5328, 5325, 3, 2, 2, 2, 5328, 5326, 3, 2, 2, 2, 5328, 5327, 3, 2, 2, 2, 5329, 529, 3, 2, 2, 2, 5330, 5334, 5, 526, 264, 2, 5331, 5334, 5, 534, 268, 2, 5332, 5334, 5, 538, 270, 2, 5333, 5330, 3, 2, 2, 2, 5333, 5331, 3, 2, 2, 2, 5333, 5332, 3, 2, 2, 2, 5334, 531, 3, 2, 2, 2, 5335, 5341, 5, 526, 264, 2, 5336, 5341, 5, 540, 271, 2, 5337, 5341, 5, 534, 268, 2, 5338, 5341, 5, 538, 270, 2, 5339, 5341, 5, 536, 269, 2, 5340, 5335, 3, 2, 2, 2, 5340, 5336, 3, 2, 2, 2, 5340, 5337, 3, 2, 2, 2, 5340, 5338, 3, 2, 2, 2, 5340, 5339, 3, 2, 2, 2, 5341, 533, 3, 2, 2, 2, 5342, 5343, 9, 73, 2, 2, 5343, 535, 3, 2, 2, 2, 5344, 5345, 9, 74, 2, 2, 5345, 537, 3, 2, 2, 2, 5346, 5347, 9, 75, 2, 2, 5347, 539, 3, 2, 2, 2, 5348, 5349, 9, 76, 2, 2, 5349, 541, 3, 2, 2, 2, 5350, 5351, 9, 77, 2, 2, 5351, 543, 3, 2, 2, 2, 5352, 5358, 5, 530, 266, 2, 5353, 5354, 5, 528, 265, 2, 5354, 5355, 7, 595, 2, 2, 5355, 5356, 5, 530, 266, 2, 5356, 5358, 3, 2, 2, 2, 5357, 5352, 3, 2, 2, 2, 5357, 5353, 3, 2, 2, 2, 5358, 545, 3, 2, 2, 2, 5359, 5364, 5, 548, 275, 2, 5360, 5361, 7, 581, 2, 2, 5361, 5363, 5, 548, 275, 2, 5362, 5360, 3, 2, 2, 2, 5363, 5366, 3, 2, 2, 2, 5364, 5362, 3, 2, 2, 2, 5364, 5365, 3, 2, 2, 2, 5365, 547, 3, 2, 2, 2, 5366, 5364, 3, 2, 2, 2, 5367, 5369, 7, 325, 2, 2, 5368, 5367, 3, 2, 2, 2, 5368, 5369, 3, 2, 2, 2, 5369, 5370, 3, 2, 2, 2, 5370, 5380, 5, 552, 277, 2, 5371, 5373, 7, 373, 2, 2, 5372, 5374, 5, 550, 276, 2, 5373, 5372, 3, 2, 2, 2, 5373, 5374, 3, 2, 2, 2, 5374, 5381, 3, 2, 2, 2, 5375, 5377, 5, 550, 276, 2, 5376, 5375, 3, 2, 2, 2, 5377, 5378, 3, 2, 2, 2, 5378, 5376, 3, 2, 2, 2, 5378, 5379, 3, 2, 2, 2, 5379, 5381, 3, 2, 2, 2, 5380, 5371, 3, 2, 2, 2, 5380, 5376, 3, 2, 2, 2, 5380, 5381, 3, 2, 2, 2, 5381, 549, 3, 2, 2, 2, 5382, 5384, 7, 599, 2, 2, 5383, 5385, 7, 610, 2, 2, 5384, 5383, 3, 2, 2, 2, 5384, 5385, 3, 2, 2, 2, 5385, 5386, 3, 2, 2, 2, 5386, 5387, 7, 600, 2, 2, 5387, 551, 3, 2, 2, 2, 5388, 5480, 7, 296, 2, 2, 5389, 5391, 7, 297, 2, 2, 5390, 5392, 7, 280, 2, 2, 5391, 5390, 3, 2, 2, 2, 5391, 5392, 3, 2, 2, 2, 5392, 5394, 3, 2, 2, 2, 5393, 5395, 5, 556, 279, 2, 5394, 5393, 3, 2, 2, 2, 5394, 5395, 3, 2, 2, 2, 5395, 5480, 3, 2, 2, 2, 5396, 5480, 7, 298, 2, 2, 5397, 5399, 7, 302, 2, 2, 5398, 5400, 5, 558, 280, 2, 5399, 5398, 3, 2, 2, 2, 5399, 5400, 3, 2, 2, 2, 5400, 5480, 3, 2, 2, 2, 5401, 5403, 7, 303, 2, 2, 5402, 5404, 5, 558, 280, 2, 5403, 5402, 3, 2, 2, 2, 5403, 5404, 3, 2, 2, 2, 5404, 5480, 3, 2, 2, 2, 5405, 5406, 7, 72, 2, 2, 5406, 5480, 7, 322, 2, 2, 5407, 5409, 7, 306, 2, 2, 5408, 5410, 5, 558, 280, 2, 5409, 5408, 3, 2, 2, 2, 5409, 5410, 3, 2, 2, 2, 5410, 5480, 3, 2, 2, 2, 5411, 5480, 7, 310, 2, 2, 5412, 5480, 7, 311, 2, 2, 5413, 5415, 7, 312, 2, 2, 5414, 5416, 5, 554, 278, 2, 5415, 5414, 3, 2, 2, 2, 5415, 5416, 3, 2, 2, 2, 5416, 5418, 3, 2, 2, 2, 5417, 5419, 5, 556, 279, 2, 5418, 5417, 3, 2, 2, 2, 5418, 5419, 3, 2, 2, 2, 5419, 5480, 3, 2, 2, 2, 5420, 5422, 7, 314, 2, 2, 5421, 5420, 3, 2, 2, 2, 5421, 5422, 3, 2, 2, 2, 5422, 5423, 3, 2, 2, 2, 5423, 5425, 9, 78, 2, 2, 5424, 5426, 7, 280, 2, 2, 5425, 5424, 3, 2, 2, 2, 5425, 5426, 3, 2, 2, 2, 5426, 5428, 3, 2, 2, 2, 5427, 5429, 5, 556, 279, 2, 5428, 5427, 3, 2, 2, 2, 5428, 5429, 3, 2, 2, 2, 5429, 5480, 3, 2, 2, 2, 5430, 5432, 7, 315, 2, 2, 5431, 5433, 7, 280, 2, 2, 5432, 5431, 3, 2, 2, 2, 5432, 5433, 3, 2, 2, 2, 5433, 5435, 3, 2, 2, 2, 5434, 5436, 5, 556, 279, 2, 5435, 5434, 3, 2, 2, 2, 5435, 5436, 3, 2, 2, 2, 5436, 5480, 3, 2, 2, 2, 5437, 5439, 7, 318, 2, 2, 5438, 5440, 5, 558, 280, 2, 5439, 5438, 3, 2, 2, 2, 5439, 5440, 3, 2, 2, 2, 5440, 5480, 3, 2, 2, 2, 5441, 5480, 7, 323, 2, 2, 5442, 5480, 7, 326, 2, 2, 5443, 5445, 7, 328, 2, 2, 5444, 5446, 5, 556, 279, 2, 5445, 5444, 3, 2, 2, 2, 5445, 5446, 3, 2, 2, 2, 5446, 5450, 3, 2, 2, 2, 5447, 5448, 9, 10, 2, 2, 5448, 5449, 7, 328, 2, 2, 5449, 5451, 7, 294, 2, 2, 5450, 5447, 3, 2, 2, 2, 5450, 5451, 3, 2, 2, 2, 5451, 5480, 3, 2, 2, 2, 5452, 5454, 7, 329, 2, 2, 5453, 5455, 5, 556, 279, 2, 5454, 5453, 3, 2, 2, 2, 5454, 5455, 3, 2, 2, 2, 5455, 5459, 3, 2, 2, 2, 5456, 5457, 9, 10, 2, 2, 5457, 5458, 7, 328, 2, 2, 5458, 5460, 7, 294, 2, 2, 5459, 5456, 3, 2, 2, 2, 5459, 5460, 3, 2, 2, 2, 5460, 5480, 3, 2, 2, 2, 5461, 5463, 7, 333, 2, 2, 5462, 5464, 5, 556, 279, 2, 5463, 5462, 3, 2, 2, 2, 5463, 5464, 3, 2, 2, 2, 5464, 5480, 3, 2, 2, 2, 5465, 5477, 5, 544, 273, 2, 5466, 5467, 7, 587, 2, 2, 5467, 5472, 5, 560, 281, 2, 5468, 5469, 7, 581, 2, 2, 5469, 5471, 5, 560, 281, 2, 5470, 5468, 3, 2, 2, 2, 5471, 5474, 3, 2, 2, 2, 5472, 5470, 3, 2, 2, 2, 5472, 5473, 3, 2, 2, 2, 5473, 5475, 3, 2, 2, 2, 5474, 5472, 3, 2, 2, 2, 5475, 5476, 7, 588, 2, 2, 5476, 5478, 3, 2, 2, 2, 5477, 5466, 3, 2, 2, 2, 5477, 5478, 3, 2, 2, 2, 5478, 5480, 3, 2, 2, 2, 5479, 5388, 3, 2, 2, 2, 5479, 5389, 3, 2, 2, 2, 5479, 5396, 3, 2, 2, 2, 5479, 5397, 3, 2, 2, 2, 5479, 5401, 3, 2, 2, 2, 5479, 5405, 3, 2, 2, 2, 5479, 5407, 3, 2, 2, 2, 5479, 5411, 3, 2, 2, 2, 5479, 5412, 3, 2, 2, 2, 5479, 5413, 3, 2, 2, 2, 5479, 5421, 3, 2, 2, 2, 5479, 5430, 3, 2, 2, 2, 5479, 5437, 3, 2, 2, 2, 5479, 5441, 3, 2, 2, 2, 5479, 5442, 3, 2, 2, 2, 5479, 5443, 3, 2, 2, 2, 5479, 5452, 3, 2, 2, 2, 5479, 5461, 3, 2, 2, 2, 5479, 5465, 3, 2, 2, 2, 5480, 553, 3, 2, 2, 2, 5481, 5509, 7, 292, 2, 2, 5482, 5509, 7, 146, 2, 2, 5483, 5509, 7, 56, 2, 2, 5484, 5509, 7, 103, 2, 2, 5485, 5509, 7, 143, 2, 2, 5486, 5509, 7, 223, 2, 2, 5487, 5488, 7, 292, 2, 2, 5488, 5489, 7, 433, 2, 2, 5489, 5509, 7, 146, 2, 2, 5490, 5491, 7, 56, 2, 2, 5491, 5492, 7, 433, 2, 2, 5492, 5509, 7, 103, 2, 2, 5493, 5494, 7, 56, 2, 2, 5494, 5495, 7, 433, 2, 2, 5495, 5509, 7, 143, 2, 2, 5496, 5497, 7, 56, 2, 2, 5497, 5498, 7, 433, 2, 2, 5498, 5509, 7, 223, 2, 2, 5499, 5500, 7, 103, 2, 2, 5500, 5501, 7, 433, 2, 2, 5501, 5509, 7, 143, 2, 2, 5502, 5503, 7, 103, 2, 2, 5503, 5504, 7, 433, 2, 2, 5504, 5509, 7, 223, 2, 2, 5505, 5506, 7, 143, 2, 2, 5506, 5507, 7, 433, 2, 2, 5507, 5509, 7, 223, 2, 2, 5508, 5481, 3, 2, 2, 2, 5508, 5482, 3, 2, 2, 2, 5508, 5483, 3, 2, 2, 2, 5508, 5484, 3, 2, 2, 2, 5508, 5485, 3, 2, 2, 2, 5508, 5486, 3, 2, 2, 2, 5508, 5487, 3, 2, 2, 2, 5508, 5490, 3, 2, 2, 2, 5508, 5493, 3, 2, 2, 2, 5508, 5496, 3, 2, 2, 2, 5508, 5499, 3, 2, 2, 2, 5508, 5502, 3, 2, 2, 2, 5508, 5505, 3, 2, 2, 2, 5509, 555, 3, 2, 2, 2, 5510, 5511, 7, 587, 2, 2, 5511, 5512, 7, 610, 2, 2, 5512, 5513, 7, 588, 2, 2, 5513, 557, 3, 2, 2, 2, 5514, 5515, 7, 587, 2, 2, 5515, 5518, 7, 610, 2, 2, 5516, 5517, 7, 581, 2, 2, 5517, 5519, 7, 610, 2, 2, 5518, 5516, 3, 2, 2, 2, 5518, 5519, 3, 2, 2, 2, 5519, 5520, 3, 2, 2, 2, 5520, 5521, 7, 588, 2, 2, 5521, 559, 3, 2, 2, 2, 5522, 5523, 8, 281, 1, 2, 5523, 5524, 7, 587, 2, 2, 5524, 5525, 5, 560, 281, 2, 5525, 5527, 7, 588, 2, 2, 5526, 5528, 5, 512, 257, 2, 5527, 5526, 3, 2, 2, 2, 5527, 5528, 3, 2, 2, 2, 5528, 5548, 3, 2, 2, 2, 5529, 5530, 7, 587, 2, 2, 5530, 5533, 5, 560, 281, 2, 5531, 5532, 7, 581, 2, 2, 5532, 5534, 5, 560, 281, 2, 5533, 5531, 3, 2, 2, 2, 5534, 5535, 3, 2, 2, 2, 5535, 5533, 3, 2, 2, 2, 5535, 5536, 3, 2, 2, 2, 5536, 5537, 3, 2, 2, 2, 5537, 5538, 7, 588, 2, 2, 5538, 5548, 3, 2, 2, 2, 5539, 5540, 9, 56, 2, 2, 5540, 5548, 5, 560, 281, 26, 5541, 5542, 5, 564, 283, 2, 5542, 5543, 5, 560, 281, 20, 5543, 5548, 3, 2, 2, 2, 5544, 5545, 7, 416, 2, 2, 5545, 5548, 5, 560, 281, 6, 5546, 5548, 5, 570, 286, 2, 5547, 5522, 3, 2, 2, 2, 5547, 5529, 3, 2, 2, 2, 5547, 5539, 3, 2, 2, 2, 5547, 5541, 3, 2, 2, 2, 5547, 5544, 3, 2, 2, 2, 5547, 5546, 3, 2, 2, 2, 5548, 5684, 3, 2, 2, 2, 5549, 5550, 12, 25, 2, 2, 5550, 5551, 7, 16, 2, 2, 5551, 5552, 7, 328, 2, 2, 5552, 5553, 7, 294, 2, 2, 5553, 5683, 5, 560, 281, 26, 5554, 5555, 12, 24, 2, 2, 5555, 5556, 7, 594, 2, 2, 5556, 5683, 5, 560, 281, 25, 5557, 5558, 12, 23, 2, 2, 5558, 5559, 9, 79, 2, 2, 5559, 5683, 5, 560, 281, 24, 5560, 5561, 12, 22, 2, 2, 5561, 5562, 9, 56, 2, 2, 5562, 5683, 5, 560, 281, 23, 5563, 5564, 12, 21, 2, 2, 5564, 5565, 5, 564, 283, 2, 5565, 5566, 5, 560, 281, 22, 5566, 5683, 3, 2, 2, 2, 5567, 5569, 12, 17, 2, 2, 5568, 5570, 7, 416, 2, 2, 5569, 5568, 3, 2, 2, 2, 5569, 5570, 3, 2, 2, 2, 5570, 5571, 3, 2, 2, 2, 5571, 5573, 7, 295, 2, 2, 5572, 5574, 9, 80, 2, 2, 5573, 5572, 3, 2, 2, 2, 5573, 5574, 3, 2, 2, 2, 5574, 5575, 3, 2, 2, 2, 5575, 5576, 5, 562, 282, 2, 5576, 5577, 7, 371, 2, 2, 5577, 5578, 5, 560, 281, 18, 5578, 5683, 3, 2, 2, 2, 5579, 5581, 12, 16, 2, 2, 5580, 5582, 7, 416, 2, 2, 5581, 5580, 3, 2, 2, 2, 5581, 5582, 3, 2, 2, 2, 5582, 5587, 3, 2, 2, 2, 5583, 5588, 7, 359, 2, 2, 5584, 5588, 7, 353, 2, 2, 5585, 5586, 7, 365, 2, 2, 5586, 5588, 7, 433, 2, 2, 5587, 5583, 3, 2, 2, 2, 5587, 5584, 3, 2, 2, 2, 5587, 5585, 3, 2, 2, 2, 5588, 5589, 3, 2, 2, 2, 5589, 5683, 5, 560, 281, 17, 5590, 5592, 12, 15, 2, 2, 5591, 5593, 7, 416, 2, 2, 5592, 5591, 3, 2, 2, 2, 5592, 5593, 3, 2, 2, 2, 5593, 5598, 3, 2, 2, 2, 5594, 5599, 7, 359, 2, 2, 5595, 5599, 7, 353, 2, 2, 5596, 5597, 7, 365, 2, 2, 5597, 5599, 7, 433, 2, 2, 5598, 5594, 3, 2, 2, 2, 5598, 5595, 3, 2, 2, 2, 5598, 5596, 3, 2, 2, 2, 5599, 5600, 3, 2, 2, 2, 5600, 5601, 5, 560, 281, 2, 5601, 5602, 7, 79, 2, 2, 5602, 5603, 5, 560, 281, 16, 5603, 5683, 3, 2, 2, 2, 5604, 5605, 12, 14, 2, 2, 5605, 5606, 9, 81, 2, 2, 5606, 5683, 5, 560, 281, 15, 5607, 5608, 12, 12, 2, 2, 5608, 5610, 7, 355, 2, 2, 5609, 5611, 7, 416, 2, 2, 5610, 5609, 3, 2, 2, 2, 5610, 5611, 3, 2, 2, 2, 5611, 5612, 3, 2, 2, 2, 5612, 5613, 7, 394, 2, 2, 5613, 5614, 7, 403, 2, 2, 5614, 5683, 5, 560, 281, 13, 5615, 5616, 12, 5, 2, 2, 5616, 5617, 7, 371, 2, 2, 5617, 5683, 5, 560, 281, 6, 5618, 5619, 12, 4, 2, 2, 5619, 5620, 7, 421, 2, 2, 5620, 5683, 5, 560, 281, 5, 5621, 5622, 12, 30, 2, 2, 5622, 5623, 7, 577, 2, 2, 5623, 5683, 5, 548, 275, 2, 5624, 5625, 12, 27, 2, 2, 5625, 5683, 5, 506, 254, 2, 5626, 5627, 12, 19, 2, 2, 5627, 5683, 5, 564, 283, 2, 5628, 5630, 12, 18, 2, 2, 5629, 5631, 7, 416, 2, 2, 5630, 5629, 3, 2, 2, 2, 5630, 5631, 3, 2, 2, 2, 5631, 5632, 3, 2, 2, 2, 5632, 5633, 7, 407, 2, 2, 5633, 5643, 7, 587, 2, 2, 5634, 5644, 5, 628, 315, 2, 5635, 5640, 5, 560, 281, 2, 5636, 5637, 7, 581, 2, 2, 5637, 5639, 5, 560, 281, 2, 5638, 5636, 3, 2, 2, 2, 5639, 5642, 3, 2, 2, 2, 5640, 5638, 3, 2, 2, 2, 5640, 5641, 3, 2, 2, 2, 5641, 5644, 3, 2, 2, 2, 5642, 5640, 3, 2, 2, 2, 5643, 5634, 3, 2, 2, 2, 5643, 5635, 3, 2, 2, 2, 5644, 5645, 3, 2, 2, 2, 5645, 5646, 7, 588, 2, 2, 5646, 5683, 3, 2, 2, 2, 5647, 5648, 12, 13, 2, 2, 5648, 5650, 7, 355, 2, 2, 5649, 5651, 7, 416, 2, 2, 5650, 5649, 3, 2, 2, 2, 5650, 5651, 3, 2, 2, 2, 5651, 5654, 3, 2, 2, 2, 5652, 5655, 5, 576, 289, 2, 5653, 5655, 7, 417, 2, 2, 5654, 5652, 3, 2, 2, 2, 5654, 5653, 3, 2, 2, 2, 5655, 5683, 3, 2, 2, 2, 5656, 5657, 12, 11, 2, 2, 5657, 5659, 7, 355, 2, 2, 5658, 5660, 7, 416, 2, 2, 5659, 5658, 3, 2, 2, 2, 5659, 5660, 3, 2, 2, 2, 5660, 5661, 3, 2, 2, 2, 5661, 5683, 7, 70, 2, 2, 5662, 5663, 12, 10, 2, 2, 5663, 5665, 7, 355, 2, 2, 5664, 5666, 7, 416, 2, 2, 5665, 5664, 3, 2, 2, 2, 5665, 5666, 3, 2, 2, 2, 5666, 5667, 3, 2, 2, 2, 5667, 5683, 7, 270, 2, 2, 5668, 5669, 12, 9, 2, 2, 5669, 5671, 7, 355, 2, 2, 5670, 5672, 7, 416, 2, 2, 5671, 5670, 3, 2, 2, 2, 5671, 5672, 3, 2, 2, 2, 5672, 5673, 3, 2, 2, 2, 5673, 5674, 7, 158, 2, 2, 5674, 5675, 7, 587, 2, 2, 5675, 5676, 5, 546, 274, 2, 5676, 5677, 7, 588, 2, 2, 5677, 5683, 3, 2, 2, 2, 5678, 5679, 12, 8, 2, 2, 5679, 5683, 7, 356, 2, 2, 5680, 5681, 12, 7, 2, 2, 5681, 5683, 7, 361, 2, 2, 5682, 5549, 3, 2, 2, 2, 5682, 5554, 3, 2, 2, 2, 5682, 5557, 3, 2, 2, 2, 5682, 5560, 3, 2, 2, 2, 5682, 5563, 3, 2, 2, 2, 5682, 5567, 3, 2, 2, 2, 5682, 5579, 3, 2, 2, 2, 5682, 5590, 3, 2, 2, 2, 5682, 5604, 3, 2, 2, 2, 5682, 5607, 3, 2, 2, 2, 5682, 5615, 3, 2, 2, 2, 5682, 5618, 3, 2, 2, 2, 5682, 5621, 3, 2, 2, 2, 5682, 5624, 3, 2, 2, 2, 5682, 5626, 3, 2, 2, 2, 5682, 5628, 3, 2, 2, 2, 5682, 5647, 3, 2, 2, 2, 5682, 5656, 3, 2, 2, 2, 5682, 5662, 3, 2, 2, 2, 5682, 5668, 3, 2, 2, 2, 5682, 5678, 3, 2, 2, 2, 5682, 5680, 3, 2, 2, 2, 5683, 5686, 3, 2, 2, 2, 5684, 5682, 3, 2, 2, 2, 5684, 5685, 3, 2, 2, 2, 5685, 561, 3, 2, 2, 2, 5686, 5684, 3, 2, 2, 2, 5687, 5688, 8, 282, 1, 2, 5688, 5689, 7, 587, 2, 2, 5689, 5690, 5, 560, 281, 2, 5690, 5692, 7, 588, 2, 2, 5691, 5693, 5, 512, 257, 2, 5692, 5691, 3, 2, 2, 2, 5692, 5693, 3, 2, 2, 2, 5693, 5711, 3, 2, 2, 2, 5694, 5695, 7, 587, 2, 2, 5695, 5698, 5, 560, 281, 2, 5696, 5697, 7, 581, 2, 2, 5697, 5699, 5, 560, 281, 2, 5698, 5696, 3, 2, 2, 2, 5699, 5700, 3, 2, 2, 2, 5700, 5698, 3, 2, 2, 2, 5700, 5701, 3, 2, 2, 2, 5701, 5702, 3, 2, 2, 2, 5702, 5703, 7, 588, 2, 2, 5703, 5711, 3, 2, 2, 2, 5704, 5705, 9, 56, 2, 2, 5705, 5711, 5, 562, 282, 15, 5706, 5707, 5, 564, 283, 2, 5707, 5708, 5, 562, 282, 10, 5708, 5711, 3, 2, 2, 2, 5709, 5711, 5, 570, 286, 2, 5710, 5687, 3, 2, 2, 2, 5710, 5694, 3, 2, 2, 2, 5710, 5704, 3, 2, 2, 2, 5710, 5706, 3, 2, 2, 2, 5710, 5709, 3, 2, 2, 2, 5711, 5765, 3, 2, 2, 2, 5712, 5713, 12, 14, 2, 2, 5713, 5714, 7, 594, 2, 2, 5714, 5764, 5, 562, 282, 15, 5715, 5716, 12, 13, 2, 2, 5716, 5717, 9, 79, 2, 2, 5717, 5764, 5, 562, 282, 14, 5718, 5719, 12, 12, 2, 2, 5719, 5720, 9, 56, 2, 2, 5720, 5764, 5, 562, 282, 13, 5721, 5722, 12, 11, 2, 2, 5722, 5723, 5, 564, 283, 2, 5723, 5724, 5, 562, 282, 12, 5724, 5764, 3, 2, 2, 2, 5725, 5726, 12, 8, 2, 2, 5726, 5727, 9, 81, 2, 2, 5727, 5764, 5, 562, 282, 9, 5728, 5729, 12, 7, 2, 2, 5729, 5731, 7, 355, 2, 2, 5730, 5732, 7, 416, 2, 2, 5731, 5730, 3, 2, 2, 2, 5731, 5732, 3, 2, 2, 2, 5732, 5733, 3, 2, 2, 2, 5733, 5734, 7, 394, 2, 2, 5734, 5735, 7, 403, 2, 2, 5735, 5764, 5, 562, 282, 8, 5736, 5737, 12, 18, 2, 2, 5737, 5738, 7, 577, 2, 2, 5738, 5764, 5, 548, 275, 2, 5739, 5740, 12, 9, 2, 2, 5740, 5764, 5, 564, 283, 2, 5741, 5742, 12, 6, 2, 2, 5742, 5744, 7, 355, 2, 2, 5743, 5745, 7, 416, 2, 2, 5744, 5743, 3, 2, 2, 2, 5744, 5745, 3, 2, 2, 2, 5745, 5746, 3, 2, 2, 2, 5746, 5764, 7, 70, 2, 2, 5747, 5748, 12, 5, 2, 2, 5748, 5750, 7, 355, 2, 2, 5749, 5751, 7, 416, 2, 2, 5750, 5749, 3, 2, 2, 2, 5750, 5751, 3, 2, 2, 2, 5751, 5752, 3, 2, 2, 2, 5752, 5764, 7, 270, 2, 2, 5753, 5754, 12, 4, 2, 2, 5754, 5756, 7, 355, 2, 2, 5755, 5757, 7, 416, 2, 2, 5756, 5755, 3, 2, 2, 2, 5756, 5757, 3, 2, 2, 2, 5757, 5758, 3, 2, 2, 2, 5758, 5759, 7, 158, 2, 2, 5759, 5760, 7, 587, 2, 2, 5760, 5761, 5, 546, 274, 2, 5761, 5762, 7, 588, 2, 2, 5762, 5764, 3, 2, 2, 2, 5763, 5712, 3, 2, 2, 2, 5763, 5715, 3, 2, 2, 2, 5763, 5718, 3, 2, 2, 2, 5763, 5721, 3, 2, 2, 2, 5763, 5725, 3, 2, 2, 2, 5763, 5728, 3, 2, 2, 2, 5763, 5736, 3, 2, 2, 2, 5763, 5739, 3, 2, 2, 2, 5763, 5741, 3, 2, 2, 2, 5763, 5747, 3, 2, 2, 2, 5763, 5753, 3, 2, 2, 2, 5764, 5767, 3, 2, 2, 2, 5765, 5763, 3, 2, 2, 2, 5765, 5766, 3, 2, 2, 2, 5766, 563, 3, 2, 2, 2, 5767, 5765, 3, 2, 2, 2, 5768, 5777, 5, 468, 235, 2, 5769, 5770, 7, 162, 2, 2, 5770, 5771, 7, 587, 2, 2, 5771, 5772, 5, 528, 265, 2, 5772, 5773, 7, 595, 2, 2, 5773, 5774, 5, 466, 234, 2, 5774, 5775, 7, 588, 2, 2, 5775, 5777, 3, 2, 2, 2, 5776, 5768, 3, 2, 2, 2, 5776, 5769, 3, 2, 2, 2, 5777, 565, 3, 2, 2, 2, 5778, 5787, 5, 466, 234, 2, 5779, 5780, 7, 162, 2, 2, 5780, 5781, 7, 587, 2, 2, 5781, 5782, 5, 528, 265, 2, 5782, 5783, 7, 595, 2, 2, 5783, 5784, 5, 466, 234, 2, 5784, 5785, 7, 588, 2, 2, 5785, 5787, 3, 2, 2, 2, 5786, 5778, 3, 2, 2, 2, 5786, 5779, 3, 2, 2, 2, 5787, 567, 3, 2, 2, 2, 5788, 5789, 7, 587, 2, 2, 5789, 5790, 5, 560, 281, 2, 5790, 5791, 7, 581, 2, 2, 5791, 5792, 5, 560, 281, 2, 5792, 5793, 7, 588, 2, 2, 5793, 5794, 7, 363, 2, 2, 5794, 5795, 7, 587, 2, 2, 5795, 5796, 5, 560, 281, 2, 5796, 5797, 7, 581, 2, 2, 5797, 5798, 5, 560, 281, 2, 5798, 5799, 7, 588, 2, 2, 5799, 569, 3, 2, 2, 2, 5800, 5819, 5, 572, 287, 2, 5801, 5802, 7, 587, 2, 2, 5802, 5803, 5, 628, 315, 2, 5803, 5805, 7, 588, 2, 2, 5804, 5806, 5, 512, 257, 2, 5805, 5804, 3, 2, 2, 2, 5805, 5806, 3, 2, 2, 2, 5806, 5819, 3, 2, 2, 2, 5807, 5819, 5, 578, 290, 2, 5808, 5819, 7, 417, 2, 2, 5809, 5819, 7, 591, 2, 2, 5810, 5819, 5, 602, 302, 2, 5811, 5812, 7, 304, 2, 2, 5812, 5819, 5, 622, 312, 2, 5813, 5819, 5, 582, 292, 2, 5814, 5819, 5, 508, 255, 2, 5815, 5819, 5, 612, 307, 2, 5816, 5819, 5, 616, 309, 2, 5817, 5819, 5, 568, 285, 2, 5818, 5800, 3, 2, 2, 2, 5818, 5801, 3, 2, 2, 2, 5818, 5807, 3, 2, 2, 2, 5818, 5808, 3, 2, 2, 2, 5818, 5809, 3, 2, 2, 2, 5818, 5810, 3, 2, 2, 2, 5818, 5811, 3, 2, 2, 2, 5818, 5813, 3, 2, 2, 2, 5818, 5814, 3, 2, 2, 2, 5818, 5815, 3, 2, 2, 2, 5818, 5816, 3, 2, 2, 2, 5818, 5817, 3, 2, 2, 2, 5819, 571, 3, 2, 2, 2, 5820, 5824, 5, 574, 288, 2, 5821, 5824, 5, 326, 164, 2, 5822, 5824, 5, 576, 289, 2, 5823, 5820, 3, 2, 2, 2, 5823, 5821, 3, 2, 2, 2, 5823, 5822, 3, 2, 2, 2, 5824, 573, 3, 2, 2, 2, 5825, 5826, 9, 82, 2, 2, 5826, 575, 3, 2, 2, 2, 5827, 5828, 9, 83, 2, 2, 5828, 577, 3, 2, 2, 2, 5829, 5831, 7, 378, 2, 2, 5830, 5832, 5, 560, 281, 2, 5831, 5830, 3, 2, 2, 2, 5831, 5832, 3, 2, 2, 2, 5832, 5838, 3, 2, 2, 2, 5833, 5834, 7, 441, 2, 2, 5834, 5835, 5, 560, 281, 2, 5835, 5836, 7, 432, 2, 2, 5836, 5837, 5, 560, 281, 2, 5837, 5839, 3, 2, 2, 2, 5838, 5833, 3, 2, 2, 2, 5839, 5840, 3, 2, 2, 2, 5840, 5838, 3, 2, 2, 2, 5840, 5841, 3, 2, 2, 2, 5841, 5844, 3, 2, 2, 2, 5842, 5843, 7, 396, 2, 2, 5843, 5845, 5, 560, 281, 2, 5844, 5842, 3, 2, 2, 2, 5844, 5845, 3, 2, 2, 2, 5845, 5846, 3, 2, 2, 2, 5846, 5847, 7, 397, 2, 2, 5847, 579, 3, 2, 2, 2, 5848, 5849, 9, 84, 2, 2, 5849, 5850, 7, 587, 2, 2, 5850, 5851, 5, 560, 281, 2, 5851, 5852, 7, 374, 2, 2, 5852, 5853, 5, 548, 275, 2, 5853, 5854, 7, 588, 2, 2, 5854, 581, 3, 2, 2, 2, 5855, 5856, 5, 544, 273, 2, 5856, 5871, 7, 587, 2, 2, 5857, 5859, 5, 620, 311, 2, 5858, 5857, 3, 2, 2, 2, 5858, 5859, 3, 2, 2, 2, 5859, 5860, 3, 2, 2, 2, 5860, 5865, 5, 584, 293, 2, 5861, 5862, 7, 581, 2, 2, 5862, 5864, 5, 584, 293, 2, 5863, 5861, 3, 2, 2, 2, 5864, 5867, 3, 2, 2, 2, 5865, 5863, 3, 2, 2, 2, 5865, 5866, 3, 2, 2, 2, 5866, 5869, 3, 2, 2, 2, 5867, 5865, 3, 2, 2, 2, 5868, 5870, 5, 664, 333, 2, 5869, 5868, 3, 2, 2, 2, 5869, 5870, 3, 2, 2, 2, 5870, 5872, 3, 2, 2, 2, 5871, 5858, 3, 2, 2, 2, 5871, 5872, 3, 2, 2, 2, 5872, 5873, 3, 2, 2, 2, 5873, 5880, 7, 588, 2, 2, 5874, 5875, 7, 286, 2, 2, 5875, 5876, 7, 405, 2, 2, 5876, 5877, 7, 587, 2, 2, 5877, 5878, 5, 664, 333, 2, 5878, 5879, 7, 588, 2, 2, 5879, 5881, 3, 2, 2, 2, 5880, 5874, 3, 2, 2, 2, 5880, 5881, 3, 2, 2, 2, 5881, 5883, 3, 2, 2, 2, 5882, 5884, 5, 604, 303, 2, 5883, 5882, 3, 2, 2, 2, 5883, 5884, 3, 2, 2, 2, 5884, 5890, 3, 2, 2, 2, 5885, 5888, 7, 167, 2, 2, 5886, 5889, 5, 528, 265, 2, 5887, 5889, 5, 606, 304, 2, 5888, 5886, 3, 2, 2, 2, 5888, 5887, 3, 2, 2, 2, 5889, 5891, 3, 2, 2, 2, 5890, 5885, 3, 2, 2, 2, 5890, 5891, 3, 2, 2, 2, 5891, 5899, 3, 2, 2, 2, 5892, 5899, 5, 588, 295, 2, 5893, 5899, 5, 590, 296, 2, 5894, 5899, 5, 592, 297, 2, 5895, 5899, 5, 594, 298, 2, 5896, 5899, 5, 596, 299, 2, 5897, 5899, 5, 598, 300, 2, 5898, 5855, 3, 2, 2, 2, 5898, 5892, 3, 2, 2, 2, 5898, 5893, 3, 2, 2, 2, 5898, 5894, 3, 2, 2, 2, 5898, 5895, 3, 2, 2, 2, 5898, 5896, 3, 2, 2, 2, 5898, 5897, 3, 2, 2, 2, 5899, 583, 3, 2, 2, 2, 5900, 5902, 7, 440, 2, 2, 5901, 5900, 3, 2, 2, 2, 5901, 5902, 3, 2, 2, 2, 5902, 5906, 3, 2, 2, 2, 5903, 5904, 5, 528, 265, 2, 5904, 5905, 5, 586, 294, 2, 5905, 5907, 3, 2, 2, 2, 5906, 5903, 3, 2, 2, 2, 5906, 5907, 3, 2, 2, 2, 5907, 5908, 3, 2, 2, 2, 5908, 5909, 5, 560, 281, 2, 5909, 585, 3, 2, 2, 2, 5910, 5911, 9, 85, 2, 2, 5911, 587, 3, 2, 2, 2, 5912, 5913, 9, 86, 2, 2, 5913, 5914, 7, 587, 2, 2, 5914, 5919, 5, 560, 281, 2, 5915, 5916, 7, 581, 2, 2, 5916, 5918, 5, 560, 281, 2, 5917, 5915, 3, 2, 2, 2, 5918, 5921, 3, 2, 2, 2, 5919, 5917, 3, 2, 2, 2, 5919, 5920, 3, 2, 2, 2, 5920, 5922, 3, 2, 2, 2, 5921, 5919, 3, 2, 2, 2, 5922, 5923, 7, 588, 2, 2, 5923, 5938, 3, 2, 2, 2, 5924, 5925, 7, 324, 2, 2, 5925, 5934, 7, 587, 2, 2, 5926, 5931, 5, 560, 281, 2, 5927, 5928, 7, 581, 2, 2, 5928, 5930, 5, 560, 281, 2, 5929, 5927, 3, 2, 2, 2, 5930, 5933, 3, 2, 2, 2, 5931, 5929, 3, 2, 2, 2, 5931, 5932, 3, 2, 2, 2, 5932, 5935, 3, 2, 2, 2, 5933, 5931, 3, 2, 2, 2, 5934, 5926, 3, 2, 2, 2, 5934, 5935, 3, 2, 2, 2, 5935, 5936, 3, 2, 2, 2, 5936, 5938, 7, 588, 2, 2, 5937, 5912, 3, 2, 2, 2, 5937, 5924, 3, 2, 2, 2, 5938, 589, 3, 2, 2, 2, 5939, 5940, 7, 305, 2, 2, 5940, 5943, 7, 587, 2, 2, 5941, 5944, 5, 528, 265, 2, 5942, 5944, 5, 326, 164, 2, 5943, 5941, 3, 2, 2, 2, 5943, 5942, 3, 2, 2, 2, 5944, 5945, 3, 2, 2, 2, 5945, 5946, 7, 403, 2, 2, 5946, 5947, 5, 560, 281, 2, 5947, 5948, 7, 588, 2, 2, 5948, 591, 3, 2, 2, 2, 5949, 5956, 7, 385, 2, 2, 5950, 5956, 7, 350, 2, 2, 5951, 5956, 7, 390, 2, 2, 5952, 5956, 7, 428, 2, 2, 5953, 5956, 7, 438, 2, 2, 5954, 5956, 5, 580, 291, 2, 5955, 5949, 3, 2, 2, 2, 5955, 5950, 3, 2, 2, 2, 5955, 5951, 3, 2, 2, 2, 5955, 5952, 3, 2, 2, 2, 5955, 5953, 3, 2, 2, 2, 5955, 5954, 3, 2, 2, 2, 5956, 593, 3, 2, 2, 2, 5957, 5975, 7, 386, 2, 2, 5958, 5960, 7, 388, 2, 2, 5959, 5961, 5, 556, 279, 2, 5960, 5959, 3, 2, 2, 2, 5960, 5961, 3, 2, 2, 2, 5961, 5975, 3, 2, 2, 2, 5962, 5964, 7, 389, 2, 2, 5963, 5965, 5, 556, 279, 2, 5964, 5963, 3, 2, 2, 2, 5964, 5965, 3, 2, 2, 2, 5965, 5975, 3, 2, 2, 2, 5966, 5968, 7, 414, 2, 2, 5967, 5969, 5, 556, 279, 2, 5968, 5967, 3, 2, 2, 2, 5968, 5969, 3, 2, 2, 2, 5969, 5975, 3, 2, 2, 2, 5970, 5972, 7, 415, 2, 2, 5971, 5973, 5, 556, 279, 2, 5972, 5971, 3, 2, 2, 2, 5972, 5973, 3, 2, 2, 2, 5973, 5975, 3, 2, 2, 2, 5974, 5957, 3, 2, 2, 2, 5974, 5958, 3, 2, 2, 2, 5974, 5962, 3, 2, 2, 2, 5974, 5966, 3, 2, 2, 2, 5974, 5970, 3, 2, 2, 2, 5975, 595, 3, 2, 2, 2, 5976, 5977, 7, 331, 2, 2, 5977, 5979, 7, 587, 2, 2, 5978, 5980, 9, 87, 2, 2, 5979, 5978, 3, 2, 2, 2, 5979, 5980, 3, 2, 2, 2, 5980, 5993, 3, 2, 2, 2, 5981, 5982, 5, 560, 281, 2, 5982, 5983, 7, 403, 2, 2, 5983, 5984, 5, 560, 281, 2, 5984, 5994, 3, 2, 2, 2, 5985, 5987, 7, 403, 2, 2, 5986, 5985, 3, 2, 2, 2, 5986, 5987, 3, 2, 2, 2, 5987, 5988, 3, 2, 2, 2, 5988, 5991, 5, 560, 281, 2, 5989, 5990, 7, 581, 2, 2, 5990, 5992, 5, 560, 281, 2, 5991, 5989, 3, 2, 2, 2, 5991, 5992, 3, 2, 2, 2, 5992, 5994, 3, 2, 2, 2, 5993, 5981, 3, 2, 2, 2, 5993, 5986, 3, 2, 2, 2, 5994, 5995, 3, 2, 2, 2, 5995, 5996, 7, 588, 2, 2, 5996, 6044, 3, 2, 2, 2, 5997, 5998, 7, 327, 2, 2, 5998, 5999, 7, 587, 2, 2, 5999, 6004, 5, 560, 281, 2, 6000, 6001, 7, 581, 2, 2, 6001, 6003, 5, 560, 281, 2, 6002, 6000, 3, 2, 2, 2, 6003, 6006, 3, 2, 2, 2, 6004, 6002, 3, 2, 2, 2, 6004, 6005, 3, 2, 2, 2, 6005, 6009, 3, 2, 2, 2, 6006, 6004, 3, 2, 2, 2, 6007, 6008, 7, 403, 2, 2, 6008, 6010, 5, 560, 281, 2, 6009, 6007, 3, 2, 2, 2, 6009, 6010, 3, 2, 2, 2, 6010, 6013, 3, 2, 2, 2, 6011, 6012, 7, 401, 2, 2, 6012, 6014, 5, 560, 281, 2, 6013, 6011, 3, 2, 2, 2, 6013, 6014, 3, 2, 2, 2, 6014, 6015, 3, 2, 2, 2, 6015, 6016, 7, 588, 2, 2, 6016, 6044, 3, 2, 2, 2, 6017, 6018, 7, 321, 2, 2, 6018, 6019, 7, 587, 2, 2, 6019, 6020, 5, 562, 282, 2, 6020, 6021, 7, 407, 2, 2, 6021, 6022, 5, 560, 281, 2, 6022, 6023, 7, 588, 2, 2, 6023, 6044, 3, 2, 2, 2, 6024, 6025, 7, 320, 2, 2, 6025, 6026, 7, 587, 2, 2, 6026, 6027, 5, 560, 281, 2, 6027, 6028, 7, 423, 2, 2, 6028, 6029, 5, 560, 281, 2, 6029, 6030, 7, 403, 2, 2, 6030, 6033, 5, 560, 281, 2, 6031, 6032, 7, 401, 2, 2, 6032, 6034, 5, 560, 281, 2, 6033, 6031, 3, 2, 2, 2, 6033, 6034, 3, 2, 2, 2, 6034, 6035, 3, 2, 2, 2, 6035, 6036, 7, 588, 2, 2, 6036, 6044, 3, 2, 2, 2, 6037, 6038, 7, 347, 2, 2, 6038, 6039, 7, 401, 2, 2, 6039, 6040, 7, 587, 2, 2, 6040, 6041, 5, 560, 281, 2, 6041, 6042, 7, 588, 2, 2, 6042, 6044, 3, 2, 2, 2, 6043, 5976, 3, 2, 2, 2, 6043, 5997, 3, 2, 2, 2, 6043, 6017, 3, 2, 2, 2, 6043, 6024, 3, 2, 2, 2, 6043, 6037, 3, 2, 2, 2, 6044, 597, 3, 2, 2, 2, 6045, 6046, 7, 336, 2, 2, 6046, 6047, 7, 587, 2, 2, 6047, 6048, 7, 148, 2, 2, 6048, 6070, 5, 528, 265, 2, 6049, 6050, 7, 581, 2, 2, 6050, 6051, 7, 334, 2, 2, 6051, 6052, 7, 587, 2, 2, 6052, 6055, 5, 560, 281, 2, 6053, 6054, 7, 374, 2, 2, 6054, 6056, 5, 528, 265, 2, 6055, 6053, 3, 2, 2, 2, 6055, 6056, 3, 2, 2, 2, 6056, 6065, 3, 2, 2, 2, 6057, 6058, 7, 581, 2, 2, 6058, 6061, 5, 560, 281, 2, 6059, 6060, 7, 374, 2, 2, 6060, 6062, 5, 528, 265, 2, 6061, 6059, 3, 2, 2, 2, 6061, 6062, 3, 2, 2, 2, 6062, 6064, 3, 2, 2, 2, 6063, 6057, 3, 2, 2, 2, 6064, 6067, 3, 2, 2, 2, 6065, 6063, 3, 2, 2, 2, 6065, 6066, 3, 2, 2, 2, 6066, 6068, 3, 2, 2, 2, 6067, 6065, 3, 2, 2, 2, 6068, 6069, 7, 588, 2, 2, 6069, 6071, 3, 2, 2, 2, 6070, 6049, 3, 2, 2, 2, 6070, 6071, 3, 2, 2, 2, 6071, 6076, 3, 2, 2, 2, 6072, 6073, 7, 581, 2, 2, 6073, 6075, 5, 560, 281, 2, 6074, 6072, 3, 2, 2, 2, 6075, 6078, 3, 2, 2, 2, 6076, 6074, 3, 2, 2, 2, 6076, 6077, 3, 2, 2, 2, 6077, 6079, 3, 2, 2, 2, 6078, 6076, 3, 2, 2, 2, 6079, 6080, 7, 588, 2, 2, 6080, 6207, 3, 2, 2, 2, 6081, 6082, 7, 338, 2, 2, 6082, 6083, 7, 587, 2, 2, 6083, 6086, 5, 560, 281, 2, 6084, 6085, 7, 374, 2, 2, 6085, 6087, 5, 528, 265, 2, 6086, 6084, 3, 2, 2, 2, 6086, 6087, 3, 2, 2, 2, 6087, 6096, 3, 2, 2, 2, 6088, 6089, 7, 581, 2, 2, 6089, 6092, 5, 560, 281, 2, 6090, 6091, 7, 374, 2, 2, 6091, 6093, 5, 528, 265, 2, 6092, 6090, 3, 2, 2, 2, 6092, 6093, 3, 2, 2, 2, 6093, 6095, 3, 2, 2, 2, 6094, 6088, 3, 2, 2, 2, 6095, 6098, 3, 2, 2, 2, 6096, 6094, 3, 2, 2, 2, 6096, 6097, 3, 2, 2, 2, 6097, 6099, 3, 2, 2, 2, 6098, 6096, 3, 2, 2, 2, 6099, 6100, 7, 588, 2, 2, 6100, 6207, 3, 2, 2, 2, 6101, 6102, 7, 341, 2, 2, 6102, 6103, 7, 587, 2, 2, 6103, 6104, 7, 148, 2, 2, 6104, 6107, 5, 528, 265, 2, 6105, 6106, 7, 581, 2, 2, 6106, 6108, 5, 560, 281, 2, 6107, 6105, 3, 2, 2, 2, 6107, 6108, 3, 2, 2, 2, 6108, 6109, 3, 2, 2, 2, 6109, 6110, 7, 588, 2, 2, 6110, 6207, 3, 2, 2, 2, 6111, 6112, 7, 342, 2, 2, 6112, 6113, 7, 587, 2, 2, 6113, 6114, 5, 560, 281, 2, 6114, 6115, 7, 581, 2, 2, 6115, 6119, 7, 281, 2, 2, 6116, 6120, 5, 560, 281, 2, 6117, 6118, 7, 152, 2, 2, 6118, 6120, 7, 279, 2, 2, 6119, 6116, 3, 2, 2, 2, 6119, 6117, 3, 2, 2, 2, 6120, 6129, 3, 2, 2, 2, 6121, 6122, 7, 581, 2, 2, 6122, 6127, 7, 239, 2, 2, 6123, 6128, 7, 293, 2, 2, 6124, 6128, 7, 152, 2, 2, 6125, 6126, 7, 152, 2, 2, 6126, 6128, 7, 279, 2, 2, 6127, 6123, 3, 2, 2, 2, 6127, 6124, 3, 2, 2, 2, 6127, 6125, 3, 2, 2, 2, 6128, 6130, 3, 2, 2, 2, 6129, 6121, 3, 2, 2, 2, 6129, 6130, 3, 2, 2, 2, 6130, 6131, 3, 2, 2, 2, 6131, 6132, 7, 588, 2, 2, 6132, 6207, 3, 2, 2, 2, 6133, 6134, 7, 337, 2, 2, 6134, 6135, 7, 587, 2, 2, 6135, 6136, 5, 560, 281, 2, 6136, 6139, 7, 175, 2, 2, 6137, 6138, 7, 22, 2, 2, 6138, 6140, 7, 196, 2, 2, 6139, 6137, 3, 2, 2, 2, 6139, 6140, 3, 2, 2, 2, 6140, 6141, 3, 2, 2, 2, 6141, 6144, 5, 560, 281, 2, 6142, 6143, 7, 22, 2, 2, 6143, 6145, 7, 196, 2, 2, 6144, 6142, 3, 2, 2, 2, 6144, 6145, 3, 2, 2, 2, 6145, 6146, 3, 2, 2, 2, 6146, 6147, 7, 588, 2, 2, 6147, 6207, 3, 2, 2, 2, 6148, 6149, 7, 340, 2, 2, 6149, 6150, 7, 587, 2, 2, 6150, 6151, 9, 42, 2, 2, 6151, 6152, 5, 560, 281, 2, 6152, 6153, 7, 588, 2, 2, 6153, 6207, 3, 2, 2, 2, 6154, 6155, 7, 343, 2, 2, 6155, 6156, 7, 587, 2, 2, 6156, 6157, 9, 42, 2, 2, 6157, 6158, 5, 560, 281, 2, 6158, 6159, 7, 374, 2, 2, 6159, 6160, 5, 548, 275, 2, 6160, 6161, 7, 588, 2, 2, 6161, 6207, 3, 2, 2, 2, 6162, 6163, 7, 344, 2, 2, 6163, 6182, 7, 587, 2, 2, 6164, 6165, 7, 339, 2, 2, 6165, 6166, 7, 587, 2, 2, 6166, 6167, 5, 560, 281, 2, 6167, 6168, 7, 374, 2, 2, 6168, 6176, 5, 528, 265, 2, 6169, 6170, 7, 581, 2, 2, 6170, 6171, 5, 560, 281, 2, 6171, 6172, 7, 374, 2, 2, 6172, 6173, 5, 528, 265, 2, 6173, 6175, 3, 2, 2, 2, 6174, 6169, 3, 2, 2, 2, 6175, 6178, 3, 2, 2, 2, 6176, 6174, 3, 2, 2, 2, 6176, 6177, 3, 2, 2, 2, 6177, 6179, 3, 2, 2, 2, 6178, 6176, 3, 2, 2, 2, 6179, 6180, 7, 588, 2, 2, 6180, 6181, 7, 581, 2, 2, 6181, 6183, 3, 2, 2, 2, 6182, 6164, 3, 2, 2, 2, 6182, 6183, 3, 2, 2, 2, 6183, 6184, 3, 2, 2, 2, 6184, 6185, 5, 560, 281, 2, 6185, 6188, 7, 175, 2, 2, 6186, 6187, 7, 22, 2, 2, 6187, 6189, 7, 196, 2, 2, 6188, 6186, 3, 2, 2, 2, 6188, 6189, 3, 2, 2, 2, 6189, 6190, 3, 2, 2, 2, 6190, 6193, 5, 560, 281, 2, 6191, 6192, 7, 22, 2, 2, 6192, 6194, 7, 196, 2, 2, 6193, 6191, 3, 2, 2, 2, 6193, 6194, 3, 2, 2, 2, 6194, 6195, 3, 2, 2, 2, 6195, 6196, 7, 35, 2, 2, 6196, 6201, 5, 600, 301, 2, 6197, 6198, 7, 581, 2, 2, 6198, 6200, 5, 600, 301, 2, 6199, 6197, 3, 2, 2, 2, 6200, 6203, 3, 2, 2, 2, 6201, 6199, 3, 2, 2, 2, 6201, 6202, 3, 2, 2, 2, 6202, 6204, 3, 2, 2, 2, 6203, 6201, 3, 2, 2, 2, 6204, 6205, 7, 588, 2, 2, 6205, 6207, 3, 2, 2, 2, 6206, 6045, 3, 2, 2, 2, 6206, 6081, 3, 2, 2, 2, 6206, 6101, 3, 2, 2, 2, 6206, 6111, 3, 2, 2, 2, 6206, 6133, 3, 2, 2, 2, 6206, 6148, 3, 2, 2, 2, 6206, 6154, 3, 2, 2, 2, 6206, 6162, 3, 2, 2, 2, 6207, 599, 3, 2, 2, 2, 6208, 6226, 5, 528, 265, 2, 6209, 6212, 5, 548, 275, 2, 6210, 6211, 7, 509, 2, 2, 6211, 6213, 5, 560, 281, 2, 6212, 6210, 3, 2, 2, 2, 6212, 6213, 3, 2, 2, 2, 6213, 6216, 3, 2, 2, 2, 6214, 6215, 7, 391, 2, 2, 6215, 6217, 5, 560, 281, 2, 6216, 6214, 3, 2, 2, 2, 6216, 6217, 3, 2, 2, 2, 6217, 6222, 3, 2, 2, 2, 6218, 6220, 7, 416, 2, 2, 6219, 6218, 3, 2, 2, 2, 6219, 6220, 3, 2, 2, 2, 6220, 6221, 3, 2, 2, 2, 6221, 6223, 7, 417, 2, 2, 6222, 6219, 3, 2, 2, 2, 6222, 6223, 3, 2, 2, 2, 6223, 6227, 3, 2, 2, 2, 6224, 6225, 7, 401, 2, 2, 6225, 6227, 7, 165, 2, 2, 6226, 6209, 3, 2, 2, 2, 6226, 6224, 3, 2, 2, 2, 6227, 601, 3, 2, 2, 2, 6228, 6229, 9, 88, 2, 2, 6229, 6232, 7, 587, 2, 2, 6230, 6233, 5, 560, 281, 2, 6231, 6233, 5, 628, 315, 2, 6232, 6230, 3, 2, 2, 2, 6232, 6231, 3, 2, 2, 2, 6233, 6234, 3, 2, 2, 2, 6234, 6235, 7, 588, 2, 2, 6235, 603, 3, 2, 2, 2, 6236, 6237, 7, 89, 2, 2, 6237, 6238, 7, 587, 2, 2, 6238, 6239, 7, 442, 2, 2, 6239, 6240, 5, 560, 281, 2, 6240, 6241, 7, 588, 2, 2, 6241, 605, 3, 2, 2, 2, 6242, 6244, 7, 587, 2, 2, 6243, 6245, 5, 528, 265, 2, 6244, 6243, 3, 2, 2, 2, 6244, 6245, 3, 2, 2, 2, 6245, 6247, 3, 2, 2, 2, 6246, 6248, 5, 502, 252, 2, 6247, 6246, 3, 2, 2, 2, 6247, 6248, 3, 2, 2, 2, 6248, 6250, 3, 2, 2, 2, 6249, 6251, 5, 664, 333, 2, 6250, 6249, 3, 2, 2, 2, 6250, 6251, 3, 2, 2, 2, 6251, 6253, 3, 2, 2, 2, 6252, 6254, 5, 608, 305, 2, 6253, 6252, 3, 2, 2, 2, 6253, 6254, 3, 2, 2, 2, 6254, 6255, 3, 2, 2, 2, 6255, 6256, 7, 588, 2, 2, 6256, 607, 3, 2, 2, 2, 6257, 6264, 9, 89, 2, 2, 6258, 6265, 5, 610, 306, 2, 6259, 6260, 7, 295, 2, 2, 6260, 6261, 5, 610, 306, 2, 6261, 6262, 7, 371, 2, 2, 6262, 6263, 5, 610, 306, 2, 6263, 6265, 3, 2, 2, 2, 6264, 6258, 3, 2, 2, 2, 6264, 6259, 3, 2, 2, 2, 6265, 6275, 3, 2, 2, 2, 6266, 6273, 7, 81, 2, 2, 6267, 6268, 7, 51, 2, 2, 6268, 6274, 7, 324, 2, 2, 6269, 6274, 7, 405, 2, 2, 6270, 6274, 7, 259, 2, 2, 6271, 6272, 7, 152, 2, 2, 6272, 6274, 7, 166, 2, 2, 6273, 6267, 3, 2, 2, 2, 6273, 6269, 3, 2, 2, 2, 6273, 6270, 3, 2, 2, 2, 6273, 6271, 3, 2, 2, 2, 6274, 6276, 3, 2, 2, 2, 6275, 6266, 3, 2, 2, 2, 6275, 6276, 3, 2, 2, 2, 6276, 609, 3, 2, 2, 2, 6277, 6278, 5, 560, 281, 2, 6278, 6279, 9, 90, 2, 2, 6279, 6283, 3, 2, 2, 2, 6280, 6281, 7, 51, 2, 2, 6281, 6283, 7, 324, 2, 2, 6282, 6277, 3, 2, 2, 2, 6282, 6280, 3, 2, 2, 2, 6283, 611, 3, 2, 2, 2, 6284, 6287, 7, 373, 2, 2, 6285, 6288, 5, 614, 308, 2, 6286, 6288, 5, 622, 312, 2, 6287, 6285, 3, 2, 2, 2, 6287, 6286, 3, 2, 2, 2, 6288, 613, 3, 2, 2, 2, 6289, 6304, 7, 599, 2, 2, 6290, 6293, 5, 560, 281, 2, 6291, 6293, 5, 614, 308, 2, 6292, 6290, 3, 2, 2, 2, 6292, 6291, 3, 2, 2, 2, 6293, 6301, 3, 2, 2, 2, 6294, 6297, 7, 581, 2, 2, 6295, 6298, 5, 560, 281, 2, 6296, 6298, 5, 614, 308, 2, 6297, 6295, 3, 2, 2, 2, 6297, 6296, 3, 2, 2, 2, 6298, 6300, 3, 2, 2, 2, 6299, 6294, 3, 2, 2, 2, 6300, 6303, 3, 2, 2, 2, 6301, 6299, 3, 2, 2, 2, 6301, 6302, 3, 2, 2, 2, 6302, 6305, 3, 2, 2, 2, 6303, 6301, 3, 2, 2, 2, 6304, 6292, 3, 2, 2, 2, 6304, 6305, 3, 2, 2, 2, 6305, 6306, 3, 2, 2, 2, 6306, 6307, 7, 600, 2, 2, 6307, 615, 3, 2, 2, 2, 6308, 6309, 5, 548, 275, 2, 6309, 6310, 5, 326, 164, 2, 6310, 6318, 3, 2, 2, 2, 6311, 6312, 7, 312, 2, 2, 6312, 6313, 5, 326, 164, 2, 6313, 6315, 5, 554, 278, 2, 6314, 6316, 5, 556, 279, 2, 6315, 6314, 3, 2, 2, 2, 6315, 6316, 3, 2, 2, 2, 6316, 6318, 3, 2, 2, 2, 6317, 6308, 3, 2, 2, 2, 6317, 6311, 3, 2, 2, 2, 6318, 617, 3, 2, 2, 2, 6319, 6326, 5, 528, 265, 2, 6320, 6321, 7, 595, 2, 2, 6321, 6324, 5, 528, 265, 2, 6322, 6323, 7, 595, 2, 2, 6323, 6325, 5, 528, 265, 2, 6324, 6322, 3, 2, 2, 2, 6324, 6325, 3, 2, 2, 2, 6325, 6327, 3, 2, 2, 2, 6326, 6320, 3, 2, 2, 2, 6326, 6327, 3, 2, 2, 2, 6327, 619, 3, 2, 2, 2, 6328, 6329, 9, 91, 2, 2, 6329, 621, 3, 2, 2, 2, 6330, 6331, 7, 587, 2, 2, 6331, 6332, 5, 624, 313, 2, 6332, 6333, 7, 588, 2, 2, 6333, 623, 3, 2, 2, 2, 6334, 6336, 5, 630, 316, 2, 6335, 6334, 3, 2, 2, 2, 6335, 6336, 3, 2, 2, 2, 6336, 6337, 3, 2, 2, 2, 6337, 6341, 5, 634, 318, 2, 6338, 6340, 5, 626, 314, 2, 6339, 6338, 3, 2, 2, 2, 6340, 6343, 3, 2, 2, 2, 6341, 6339, 3, 2, 2, 2, 6341, 6342, 3, 2, 2, 2, 6342, 625, 3, 2, 2, 2, 6343, 6341, 3, 2, 2, 2, 6344, 6391, 5, 664, 333, 2, 6345, 6348, 7, 413, 2, 2, 6346, 6349, 5, 560, 281, 2, 6347, 6349, 7, 368, 2, 2, 6348, 6346, 3, 2, 2, 2, 6348, 6347, 3, 2, 2, 2, 6349, 6391, 3, 2, 2, 2, 6350, 6351, 7, 418, 2, 2, 6351, 6353, 5, 560, 281, 2, 6352, 6354, 9, 92, 2, 2, 6353, 6352, 3, 2, 2, 2, 6353, 6354, 3, 2, 2, 2, 6354, 6391, 3, 2, 2, 2, 6355, 6356, 7, 400, 2, 2, 6356, 6358, 9, 93, 2, 2, 6357, 6359, 5, 560, 281, 2, 6358, 6357, 3, 2, 2, 2, 6358, 6359, 3, 2, 2, 2, 6359, 6360, 3, 2, 2, 2, 6360, 6362, 9, 92, 2, 2, 6361, 6363, 7, 420, 2, 2, 6362, 6361, 3, 2, 2, 2, 6362, 6363, 3, 2, 2, 2, 6363, 6391, 3, 2, 2, 2, 6364, 6372, 7, 401, 2, 2, 6365, 6373, 7, 274, 2, 2, 6366, 6367, 7, 152, 2, 2, 6367, 6368, 7, 124, 2, 2, 6368, 6373, 7, 274, 2, 2, 6369, 6373, 7, 232, 2, 2, 6370, 6371, 7, 124, 2, 2, 6371, 6373, 7, 232, 2, 2, 6372, 6365, 3, 2, 2, 2, 6372, 6366, 3, 2, 2, 2, 6372, 6369, 3, 2, 2, 2, 6372, 6370, 3, 2, 2, 2, 6373, 6383, 3, 2, 2, 2, 6374, 6375, 7, 158, 2, 2, 6375, 6380, 5, 618, 310, 2, 6376, 6377, 7, 581, 2, 2, 6377, 6379, 5, 618, 310, 2, 6378, 6376, 3, 2, 2, 2, 6379, 6382, 3, 2, 2, 2, 6380, 6378, 3, 2, 2, 2, 6380, 6381, 3, 2, 2, 2, 6381, 6384, 3, 2, 2, 2, 6382, 6380, 3, 2, 2, 2, 6383, 6374, 3, 2, 2, 2, 6383, 6384, 3, 2, 2, 2, 6384, 6388, 3, 2, 2, 2, 6385, 6389, 7, 155, 2, 2, 6386, 6387, 7, 235, 2, 2, 6387, 6389, 7, 136, 2, 2, 6388, 6385, 3, 2, 2, 2, 6388, 6386, 3, 2, 2, 2, 6388, 6389, 3, 2, 2, 2, 6389, 6391, 3, 2, 2, 2, 6390, 6344, 3, 2, 2, 2, 6390, 6345, 3, 2, 2, 2, 6390, 6350, 3, 2, 2, 2, 6390, 6355, 3, 2, 2, 2, 6390, 6364, 3, 2, 2, 2, 6391, 627, 3, 2, 2, 2, 6392, 6394, 5, 630, 316, 2, 6393, 6392, 3, 2, 2, 2, 6393, 6394, 3, 2, 2, 2, 6394, 6395, 3, 2, 2, 2, 6395, 6399, 5, 636, 319, 2, 6396, 6398, 5, 626, 314, 2, 6397, 6396, 3, 2, 2, 2, 6398, 6401, 3, 2, 2, 2, 6399, 6397, 3, 2, 2, 2, 6399, 6400, 3, 2, 2, 2, 6400, 629, 3, 2, 2, 2, 6401, 6399, 3, 2, 2, 2, 6402, 6404, 7, 444, 2, 2, 6403, 6405, 7, 195, 2, 2, 6404, 6403, 3, 2, 2, 2, 6404, 6405, 3, 2, 2, 2, 6405, 6406, 3, 2, 2, 2, 6406, 6411, 5, 632, 317, 2, 6407, 6408, 7, 581, 2, 2, 6408, 6410, 5, 632, 317, 2, 6409, 6407, 3, 2, 2, 2, 6410, 6413, 3, 2, 2, 2, 6411, 6409, 3, 2, 2, 2, 6411, 6412, 3, 2, 2, 2, 6412, 631, 3, 2, 2, 2, 6413, 6411, 3, 2, 2, 2, 6414, 6426, 5, 528, 265, 2, 6415, 6416, 7, 587, 2, 2, 6416, 6421, 5, 528, 265, 2, 6417, 6418, 7, 581, 2, 2, 6418, 6420, 5, 528, 265, 2, 6419, 6417, 3, 2, 2, 2, 6420, 6423, 3, 2, 2, 2, 6421, 6419, 3, 2, 2, 2, 6421, 6422, 3, 2, 2, 2, 6422, 6424, 3, 2, 2, 2, 6423, 6421, 3, 2, 2, 2, 6424, 6425, 7, 588, 2, 2, 6425, 6427, 3, 2, 2, 2, 6426, 6415, 3, 2, 2, 2, 6426, 6427, 3, 2, 2, 2, 6427, 6428, 3, 2, 2, 2, 6428, 6433, 7, 374, 2, 2, 6429, 6431, 7, 416, 2, 2, 6430, 6429, 3, 2, 2, 2, 6430, 6431, 3, 2, 2, 2, 6431, 6432, 3, 2, 2, 2, 6432, 6434, 7, 140, 2, 2, 6433, 6430, 3, 2, 2, 2, 6433, 6434, 3, 2, 2, 2, 6434, 6435, 3, 2, 2, 2, 6435, 6436, 7, 587, 2, 2, 6436, 6437, 5, 16, 9, 2, 6437, 6438, 7, 588, 2, 2, 6438, 633, 3, 2, 2, 2, 6439, 6440, 8, 318, 1, 2, 6440, 6441, 7, 587, 2, 2, 6441, 6442, 5, 624, 313, 2, 6442, 6443, 7, 588, 2, 2, 6443, 6446, 3, 2, 2, 2, 6444, 6446, 5, 638, 320, 2, 6445, 6439, 3, 2, 2, 2, 6445, 6444, 3, 2, 2, 2, 6446, 6455, 3, 2, 2, 2, 6447, 6448, 12, 4, 2, 2, 6448, 6450, 9, 94, 2, 2, 6449, 6451, 5, 620, 311, 2, 6450, 6449, 3, 2, 2, 2, 6450, 6451, 3, 2, 2, 2, 6451, 6452, 3, 2, 2, 2, 6452, 6454, 5, 634, 318, 5, 6453, 6447, 3, 2, 2, 2, 6454, 6457, 3, 2, 2, 2, 6455, 6453, 3, 2, 2, 2, 6455, 6456, 3, 2, 2, 2, 6456, 635, 3, 2, 2, 2, 6457, 6455, 3, 2, 2, 2, 6458, 6459, 5, 634, 318, 2, 6459, 6461, 9, 94, 2, 2, 6460, 6462, 5, 620, 311, 2, 6461, 6460, 3, 2, 2, 2, 6461, 6462, 3, 2, 2, 2, 6462, 6468, 3, 2, 2, 2, 6463, 6469, 5, 638, 320, 2, 6464, 6465, 7, 587, 2, 2, 6465, 6466, 5, 624, 313, 2, 6466, 6467, 7, 588, 2, 2, 6467, 6469, 3, 2, 2, 2, 6468, 6463, 3, 2, 2, 2, 6468, 6464, 3, 2, 2, 2, 6469, 6472, 3, 2, 2, 2, 6470, 6472, 5, 638, 320, 2, 6471, 6458, 3, 2, 2, 2, 6471, 6470, 3, 2, 2, 2, 6472, 637, 3, 2, 2, 2, 6473, 6489, 7, 427, 2, 2, 6474, 6487, 5, 620, 311, 2, 6475, 6476, 7, 419, 2, 2, 6476, 6477, 7, 587, 2, 2, 6477, 6482, 5, 560, 281, 2, 6478, 6479, 7, 581, 2, 2, 6479, 6481, 5, 560, 281, 2, 6480, 6478, 3, 2, 2, 2, 6481, 6484, 3, 2, 2, 2, 6482, 6480, 3, 2, 2, 2, 6482, 6483, 3, 2, 2, 2, 6483, 6485, 3, 2, 2, 2, 6484, 6482, 3, 2, 2, 2, 6485, 6486, 7, 588, 2, 2, 6486, 6488, 3, 2, 2, 2, 6487, 6475, 3, 2, 2, 2, 6487, 6488, 3, 2, 2, 2, 6488, 6490, 3, 2, 2, 2, 6489, 6474, 3, 2, 2, 2, 6489, 6490, 3, 2, 2, 2, 6490, 6492, 3, 2, 2, 2, 6491, 6493, 5, 640, 321, 2, 6492, 6491, 3, 2, 2, 2, 6492, 6493, 3, 2, 2, 2, 6493, 6495, 3, 2, 2, 2, 6494, 6496, 5, 644, 323, 2, 6495, 6494, 3, 2, 2, 2, 6495, 6496, 3, 2, 2, 2, 6496, 6506, 3, 2, 2, 2, 6497, 6498, 7, 403, 2, 2, 6498, 6503, 5, 646, 324, 2, 6499, 6500, 7, 581, 2, 2, 6500, 6502, 5, 646, 324, 2, 6501, 6499, 3, 2, 2, 2, 6502, 6505, 3, 2, 2, 2, 6503, 6501, 3, 2, 2, 2, 6503, 6504, 3, 2, 2, 2, 6504, 6507, 3, 2, 2, 2, 6505, 6503, 3, 2, 2, 2, 6506, 6497, 3, 2, 2, 2, 6506, 6507, 3, 2, 2, 2, 6507, 6510, 3, 2, 2, 2, 6508, 6509, 7, 442, 2, 2, 6509, 6511, 5, 560, 281, 2, 6510, 6508, 3, 2, 2, 2, 6510, 6511, 3, 2, 2, 2, 6511, 6513, 3, 2, 2, 2, 6512, 6514, 5, 654, 328, 2, 6513, 6512, 3, 2, 2, 2, 6513, 6514, 3, 2, 2, 2, 6514, 6517, 3, 2, 2, 2, 6515, 6516, 7, 406, 2, 2, 6516, 6518, 5, 560, 281, 2, 6517, 6515, 3, 2, 2, 2, 6517, 6518, 3, 2, 2, 2, 6518, 6533, 3, 2, 2, 2, 6519, 6520, 7, 443, 2, 2, 6520, 6521, 5, 528, 265, 2, 6521, 6522, 7, 374, 2, 2, 6522, 6530, 5, 606, 304, 2, 6523, 6524, 7, 581, 2, 2, 6524, 6525, 5, 528, 265, 2, 6525, 6526, 7, 374, 2, 2, 6526, 6527, 5, 606, 304, 2, 6527, 6529, 3, 2, 2, 2, 6528, 6523, 3, 2, 2, 2, 6529, 6532, 3, 2, 2, 2, 6530, 6528, 3, 2, 2, 2, 6530, 6531, 3, 2, 2, 2, 6531, 6534, 3, 2, 2, 2, 6532, 6530, 3, 2, 2, 2, 6533, 6519, 3, 2, 2, 2, 6533, 6534, 3, 2, 2, 2, 6534, 6545, 3, 2, 2, 2, 6535, 6537, 7, 431, 2, 2, 6536, 6538, 7, 420, 2, 2, 6537, 6536, 3, 2, 2, 2, 6537, 6538, 3, 2, 2, 2, 6538, 6539, 3, 2, 2, 2, 6539, 6541, 5, 618, 310, 2, 6540, 6542, 7, 591, 2, 2, 6541, 6540, 3, 2, 2, 2, 6541, 6542, 3, 2, 2, 2, 6542, 6545, 3, 2, 2, 2, 6543, 6545, 5, 660, 331, 2, 6544, 6473, 3, 2, 2, 2, 6544, 6535, 3, 2, 2, 2, 6544, 6543, 3, 2, 2, 2, 6545, 639, 3, 2, 2, 2, 6546, 6551, 5, 642, 322, 2, 6547, 6548, 7, 581, 2, 2, 6548, 6550, 5, 642, 322, 2, 6549, 6547, 3, 2, 2, 2, 6550, 6553, 3, 2, 2, 2, 6551, 6549, 3, 2, 2, 2, 6551, 6552, 3, 2, 2, 2, 6552, 641, 3, 2, 2, 2, 6553, 6551, 3, 2, 2, 2, 6554, 6558, 5, 560, 281, 2, 6555, 6556, 7, 374, 2, 2, 6556, 6559, 5, 532, 267, 2, 6557, 6559, 5, 526, 264, 2, 6558, 6555, 3, 2, 2, 2, 6558, 6557, 3, 2, 2, 2, 6558, 6559, 3, 2, 2, 2, 6559, 643, 3, 2, 2, 2, 6560, 6562, 7, 410, 2, 2, 6561, 6563, 9, 95, 2, 2, 6562, 6561, 3, 2, 2, 2, 6562, 6563, 3, 2, 2, 2, 6563, 6565, 3, 2, 2, 2, 6564, 6566, 7, 431, 2, 2, 6565, 6564, 3, 2, 2, 2, 6565, 6566, 3, 2, 2, 2, 6566, 6567, 3, 2, 2, 2, 6567, 6568, 5, 618, 310, 2, 6568, 645, 3, 2, 2, 2, 6569, 6570, 8, 324, 1, 2, 6570, 6571, 7, 587, 2, 2, 6571, 6572, 5, 646, 324, 2, 6572, 6574, 7, 588, 2, 2, 6573, 6575, 5, 650, 326, 2, 6574, 6573, 3, 2, 2, 2, 6574, 6575, 3, 2, 2, 2, 6575, 6578, 3, 2, 2, 2, 6576, 6578, 5, 648, 325, 2, 6577, 6569, 3, 2, 2, 2, 6577, 6576, 3, 2, 2, 2, 6578, 6622, 3, 2, 2, 2, 6579, 6580, 12, 7, 2, 2, 6580, 6581, 7, 349, 2, 2, 6581, 6582, 7, 357, 2, 2, 6582, 6621, 5, 646, 324, 8, 6583, 6584, 12, 4, 2, 2, 6584, 6590, 7, 360, 2, 2, 6585, 6591, 7, 354, 2, 2, 6586, 6588, 9, 96, 2, 2, 6587, 6589, 7, 362, 2, 2, 6588, 6587, 3, 2, 2, 2, 6588, 6589, 3, 2, 2, 2, 6589, 6591, 3, 2, 2, 2, 6590, 6585, 3, 2, 2, 2, 6590, 6586, 3, 2, 2, 2, 6590, 6591, 3, 2, 2, 2, 6591, 6592, 3, 2, 2, 2, 6592, 6593, 7, 357, 2, 2, 6593, 6621, 5, 646, 324, 5, 6594, 6600, 12, 6, 2, 2, 6595, 6601, 7, 354, 2, 2, 6596, 6598, 9, 96, 2, 2, 6597, 6599, 7, 362, 2, 2, 6598, 6597, 3, 2, 2, 2, 6598, 6599, 3, 2, 2, 2, 6599, 6601, 3, 2, 2, 2, 6600, 6595, 3, 2, 2, 2, 6600, 6596, 3, 2, 2, 2, 6600, 6601, 3, 2, 2, 2, 6601, 6602, 3, 2, 2, 2, 6602, 6603, 7, 357, 2, 2, 6603, 6604, 5, 646, 324, 2, 6604, 6605, 7, 419, 2, 2, 6605, 6606, 5, 560, 281, 2, 6606, 6621, 3, 2, 2, 2, 6607, 6613, 12, 5, 2, 2, 6608, 6614, 7, 354, 2, 2, 6609, 6611, 9, 96, 2, 2, 6610, 6612, 7, 362, 2, 2, 6611, 6610, 3, 2, 2, 2, 6611, 6612, 3, 2, 2, 2, 6612, 6614, 3, 2, 2, 2, 6613, 6608, 3, 2, 2, 2, 6613, 6609, 3, 2, 2, 2, 6613, 6614, 3, 2, 2, 2, 6614, 6615, 3, 2, 2, 2, 6615, 6616, 7, 357, 2, 2, 6616, 6617, 5, 646, 324, 2, 6617, 6618, 7, 439, 2, 2, 6618, 6619, 5, 472, 237, 2, 6619, 6621, 3, 2, 2, 2, 6620, 6579, 3, 2, 2, 2, 6620, 6583, 3, 2, 2, 2, 6620, 6594, 3, 2, 2, 2, 6620, 6607, 3, 2, 2, 2, 6621, 6624, 3, 2, 2, 2, 6622, 6620, 3, 2, 2, 2, 6622, 6623, 3, 2, 2, 2, 6623, 647, 3, 2, 2, 2, 6624, 6622, 3, 2, 2, 2, 6625, 6627, 7, 420, 2, 2, 6626, 6625, 3, 2, 2, 2, 6626, 6627, 3, 2, 2, 2, 6627, 6628, 3, 2, 2, 2, 6628, 6630, 5, 618, 310, 2, 6629, 6631, 7, 591, 2, 2, 6630, 6629, 3, 2, 2, 2, 6630, 6631, 3, 2, 2, 2, 6631, 6633, 3, 2, 2, 2, 6632, 6634, 5, 650, 326, 2, 6633, 6632, 3, 2, 2, 2, 6633, 6634, 3, 2, 2, 2, 6634, 6651, 3, 2, 2, 2, 6635, 6636, 7, 366, 2, 2, 6636, 6637, 5, 528, 265, 2, 6637, 6638, 7, 587, 2, 2, 6638, 6643, 5, 560, 281, 2, 6639, 6640, 7, 581, 2, 2, 6640, 6642, 5, 560, 281, 2, 6641, 6639, 3, 2, 2, 2, 6642, 6645, 3, 2, 2, 2, 6643, 6641, 3, 2, 2, 2, 6643, 6644, 3, 2, 2, 2, 6644, 6646, 3, 2, 2, 2, 6645, 6643, 3, 2, 2, 2, 6646, 6649, 7, 588, 2, 2, 6647, 6648, 7, 203, 2, 2, 6648, 6650, 5, 560, 281, 2, 6649, 6647, 3, 2, 2, 2, 6649, 6650, 3, 2, 2, 2, 6650, 6652, 3, 2, 2, 2, 6651, 6635, 3, 2, 2, 2, 6651, 6652, 3, 2, 2, 2, 6652, 6736, 3, 2, 2, 2, 6653, 6655, 7, 411, 2, 2, 6654, 6653, 3, 2, 2, 2, 6654, 6655, 3, 2, 2, 2, 6655, 6656, 3, 2, 2, 2, 6656, 6657, 5, 622, 312, 2, 6657, 6658, 5, 650, 326, 2, 6658, 6736, 3, 2, 2, 2, 6659, 6661, 7, 411, 2, 2, 6660, 6659, 3, 2, 2, 2, 6660, 6661, 3, 2, 2, 2, 6661, 6662, 3, 2, 2, 2, 6662, 6665, 5, 582, 292, 2, 6663, 6664, 7, 444, 2, 2, 6664, 6666, 7, 165, 2, 2, 6665, 6663, 3, 2, 2, 2, 6665, 6666, 3, 2, 2, 2, 6666, 6687, 3, 2, 2, 2, 6667, 6668, 7, 374, 2, 2, 6668, 6688, 5, 652, 327, 2, 6669, 6671, 7, 374, 2, 2, 6670, 6669, 3, 2, 2, 2, 6670, 6671, 3, 2, 2, 2, 6671, 6672, 3, 2, 2, 2, 6672, 6685, 5, 528, 265, 2, 6673, 6674, 7, 587, 2, 2, 6674, 6679, 5, 528, 265, 2, 6675, 6676, 7, 581, 2, 2, 6676, 6678, 5, 528, 265, 2, 6677, 6675, 3, 2, 2, 2, 6678, 6681, 3, 2, 2, 2, 6679, 6677, 3, 2, 2, 2, 6679, 6680, 3, 2, 2, 2, 6680, 6682, 3, 2, 2, 2, 6681, 6679, 3, 2, 2, 2, 6682, 6683, 7, 588, 2, 2, 6683, 6686, 3, 2, 2, 2, 6684, 6686, 5, 652, 327, 2, 6685, 6673, 3, 2, 2, 2, 6685, 6684, 3, 2, 2, 2, 6685, 6686, 3, 2, 2, 2, 6686, 6688, 3, 2, 2, 2, 6687, 6667, 3, 2, 2, 2, 6687, 6670, 3, 2, 2, 2, 6687, 6688, 3, 2, 2, 2, 6688, 6736, 3, 2, 2, 2, 6689, 6691, 7, 411, 2, 2, 6690, 6689, 3, 2, 2, 2, 6690, 6691, 3, 2, 2, 2, 6691, 6692, 3, 2, 2, 2, 6692, 6693, 7, 216, 2, 2, 6693, 6694, 7, 403, 2, 2, 6694, 6695, 7, 587, 2, 2, 6695, 6698, 5, 582, 292, 2, 6696, 6697, 7, 374, 2, 2, 6697, 6699, 5, 652, 327, 2, 6698, 6696, 3, 2, 2, 2, 6698, 6699, 3, 2, 2, 2, 6699, 6708, 3, 2, 2, 2, 6700, 6701, 7, 581, 2, 2, 6701, 6704, 5, 582, 292, 2, 6702, 6703, 7, 374, 2, 2, 6703, 6705, 5, 652, 327, 2, 6704, 6702, 3, 2, 2, 2, 6704, 6705, 3, 2, 2, 2, 6705, 6707, 3, 2, 2, 2, 6706, 6700, 3, 2, 2, 2, 6707, 6710, 3, 2, 2, 2, 6708, 6706, 3, 2, 2, 2, 6708, 6709, 3, 2, 2, 2, 6709, 6711, 3, 2, 2, 2, 6710, 6708, 3, 2, 2, 2, 6711, 6714, 7, 588, 2, 2, 6712, 6713, 7, 444, 2, 2, 6713, 6715, 7, 165, 2, 2, 6714, 6712, 3, 2, 2, 2, 6714, 6715, 3, 2, 2, 2, 6715, 6733, 3, 2, 2, 2, 6716, 6718, 7, 374, 2, 2, 6717, 6716, 3, 2, 2, 2, 6717, 6718, 3, 2, 2, 2, 6718, 6719, 3, 2, 2, 2, 6719, 6731, 5, 528, 265, 2, 6720, 6721, 7, 587, 2, 2, 6721, 6726, 5, 528, 265, 2, 6722, 6723, 7, 581, 2, 2, 6723, 6725, 5, 528, 265, 2, 6724, 6722, 3, 2, 2, 2, 6725, 6728, 3, 2, 2, 2, 6726, 6724, 3, 2, 2, 2, 6726, 6727, 3, 2, 2, 2, 6727, 6729, 3, 2, 2, 2, 6728, 6726, 3, 2, 2, 2, 6729, 6730, 7, 588, 2, 2, 6730, 6732, 3, 2, 2, 2, 6731, 6720, 3, 2, 2, 2, 6731, 6732, 3, 2, 2, 2, 6732, 6734, 3, 2, 2, 2, 6733, 6717, 3, 2, 2, 2, 6733, 6734, 3, 2, 2, 2, 6734, 6736, 3, 2, 2, 2, 6735, 6626, 3, 2, 2, 2, 6735, 6654, 3, 2, 2, 2, 6735, 6660, 3, 2, 2, 2, 6735, 6690, 3, 2, 2, 2, 6736, 649, 3, 2, 2, 2, 6737, 6739, 7, 374, 2, 2, 6738, 6737, 3, 2, 2, 2, 6738, 6739, 3, 2, 2, 2, 6739, 6740, 3, 2, 2, 2, 6740, 6752, 5, 528, 265, 2, 6741, 6742, 7, 587, 2, 2, 6742, 6747, 5, 528, 265, 2, 6743, 6744, 7, 581, 2, 2, 6744, 6746, 5, 528, 265, 2, 6745, 6743, 3, 2, 2, 2, 6746, 6749, 3, 2, 2, 2, 6747, 6745, 3, 2, 2, 2, 6747, 6748, 3, 2, 2, 2, 6748, 6750, 3, 2, 2, 2, 6749, 6747, 3, 2, 2, 2, 6750, 6751, 7, 588, 2, 2, 6751, 6753, 3, 2, 2, 2, 6752, 6741, 3, 2, 2, 2, 6752, 6753, 3, 2, 2, 2, 6753, 651, 3, 2, 2, 2, 6754, 6755, 7, 587, 2, 2, 6755, 6756, 5, 528, 265, 2, 6756, 6763, 5, 548, 275, 2, 6757, 6758, 7, 581, 2, 2, 6758, 6759, 5, 528, 265, 2, 6759, 6760, 5, 548, 275, 2, 6760, 6762, 3, 2, 2, 2, 6761, 6757, 3, 2, 2, 2, 6762, 6765, 3, 2, 2, 2, 6763, 6761, 3, 2, 2, 2, 6763, 6764, 3, 2, 2, 2, 6764, 6766, 3, 2, 2, 2, 6765, 6763, 3, 2, 2, 2, 6766, 6767, 7, 588, 2, 2, 6767, 653, 3, 2, 2, 2, 6768, 6769, 7, 405, 2, 2, 6769, 6770, 7, 22, 2, 2, 6770, 6771, 5, 656, 329, 2, 6771, 655, 3, 2, 2, 2, 6772, 6777, 5, 658, 330, 2, 6773, 6774, 7, 581, 2, 2, 6774, 6776, 5, 658, 330, 2, 6775, 6773, 3, 2, 2, 2, 6776, 6779, 3, 2, 2, 2, 6777, 6775, 3, 2, 2, 2, 6777, 6778, 3, 2, 2, 2, 6778, 657, 3, 2, 2, 2, 6779, 6777, 3, 2, 2, 2, 6780, 6794, 5, 560, 281, 2, 6781, 6782, 7, 587, 2, 2, 6782, 6794, 7, 588, 2, 2, 6783, 6788, 7, 213, 2, 2, 6784, 6788, 7, 50, 2, 2, 6785, 6786, 7, 308, 2, 2, 6786, 6788, 7, 231, 2, 2, 6787, 6783, 3, 2, 2, 2, 6787, 6784, 3, 2, 2, 2, 6787, 6785, 3, 2, 2, 2, 6788, 6789, 3, 2, 2, 2, 6789, 6790, 7, 587, 2, 2, 6790, 6791, 5, 656, 329, 2, 6791, 6792, 7, 588, 2, 2, 6792, 6794, 3, 2, 2, 2, 6793, 6780, 3, 2, 2, 2, 6793, 6781, 3, 2, 2, 2, 6793, 6787, 3, 2, 2, 2, 6794, 659, 3, 2, 2, 2, 6795, 6796, 7, 332, 2, 2, 6796, 6801, 5, 662, 332, 2, 6797, 6798, 7, 581, 2, 2, 6798, 6800, 5, 662, 332, 2, 6799, 6797, 3, 2, 2, 2, 6800, 6803, 3, 2, 2, 2, 6801, 6799, 3, 2, 2, 2, 6801, 6802, 3, 2, 2, 2, 6802, 661, 3, 2, 2, 2, 6803, 6801, 3, 2, 2, 2, 6804, 6807, 7, 587, 2, 2, 6805, 6808, 5, 560, 281, 2, 6806, 6808, 7, 391, 2, 2, 6807, 6805, 3, 2, 2, 2, 6807, 6806, 3, 2, 2, 2, 6808, 6816, 3, 2, 2, 2, 6809, 6812, 7, 581, 2, 2, 6810, 6813, 5, 560, 281, 2, 6811, 6813, 7, 391, 2, 2, 6812, 6810, 3, 2, 2, 2, 6812, 6811, 3, 2, 2, 2, 6813, 6815, 3, 2, 2, 2, 6814, 6809, 3, 2, 2, 2, 6815, 6818, 3, 2, 2, 2, 6816, 6814, 3, 2, 2, 2, 6816, 6817, 3, 2, 2, 2, 6817, 6819, 3, 2, 2, 2, 6818, 6816, 3, 2, 2, 2, 6819, 6820, 7, 588, 2, 2, 6820, 663, 3, 2, 2, 2, 6821, 6822, 7, 422, 2, 2, 6822, 6823, 7, 22, 2, 2, 6823, 6824, 5, 666, 334, 2, 6824, 665, 3, 2, 2, 2, 6825, 6830, 5, 668, 335, 2, 6826, 6827, 7, 581, 2, 2, 6827, 6829, 5, 668, 335, 2, 6828, 6826, 3, 2, 2, 2, 6829, 6832, 3, 2, 2, 2, 6830, 6828, 3, 2, 2, 2, 6830, 6831, 3, 2, 2, 2, 6831, 667, 3, 2, 2, 2, 6832, 6830, 3, 2, 2, 2, 6833, 6835, 5, 560, 281, 2, 6834, 6836, 5, 618, 310, 2, 6835, 6834, 3, 2, 2, 2, 6835, 6836, 3, 2, 2, 2, 6836, 6838, 3, 2, 2, 2, 6837, 6839, 5, 670, 336, 2, 6838, 6837, 3, 2, 2, 2, 6838, 6839, 3, 2, 2, 2, 6839, 6841, 3, 2, 2, 2, 6840, 6842, 5, 672, 337, 2, 6841, 6840, 3, 2, 2, 2, 6841, 6842, 3, 2, 2, 2, 6842, 669, 3, 2, 2, 2, 6843, 6848, 7, 375, 2, 2, 6844, 6848, 7, 393, 2, 2, 6845, 6846, 7, 439, 2, 2, 6846, 6848, 5, 566, 284, 2, 6847, 6843, 3, 2, 2, 2, 6847, 6844, 3, 2, 2, 2, 6847, 6845, 3, 2, 2, 2, 6848, 671, 3, 2, 2, 2, 6849, 6850, 7, 156, 2, 2, 6850, 6851, 9, 97, 2, 2, 6851, 673, 3, 2, 2, 2, 6852, 6854, 5, 630, 316, 2, 6853, 6852, 3, 2, 2, 2, 6853, 6854, 3, 2, 2, 2, 6854, 6855, 3, 2, 2, 2, 6855, 6856, 7, 120, 2, 2, 6856, 6857, 7, 410, 2, 2, 6857, 6860, 5, 618, 310, 2, 6858, 6859, 7, 374, 2, 2, 6859, 6861, 5, 528, 265, 2, 6860, 6858, 3, 2, 2, 2, 6860, 6861, 3, 2, 2, 2, 6861, 6865, 3, 2, 2, 2, 6862, 6863, 7, 168, 2, 2, 6863, 6864, 9, 98, 2, 2, 6864, 6866, 7, 279, 2, 2, 6865, 6862, 3, 2, 2, 2, 6865, 6866, 3, 2, 2, 2, 6866, 6868, 3, 2, 2, 2, 6867, 6869, 5, 676, 339, 2, 6868, 6867, 3, 2, 2, 2, 6868, 6869, 3, 2, 2, 2, 6869, 6873, 3, 2, 2, 2, 6870, 6874, 5, 624, 313, 2, 6871, 6872, 7, 391, 2, 2, 6872, 6874, 7, 332, 2, 2, 6873, 6870, 3, 2, 2, 2, 6873, 6871, 3, 2, 2, 2, 6874, 6881, 3, 2, 2, 2, 6875, 6876, 7, 419, 2, 2, 6876, 6878, 7, 41, 2, 2, 6877, 6879, 5, 680, 341, 2, 6878, 6877, 3, 2, 2, 2, 6878, 6879, 3, 2, 2, 2, 6879, 6880, 3, 2, 2, 2, 6880, 6882, 5, 682, 342, 2, 6881, 6875, 3, 2, 2, 2, 6881, 6882, 3, 2, 2, 2, 6882, 6885, 3, 2, 2, 2, 6883, 6884, 7, 426, 2, 2, 6884, 6886, 5, 640, 321, 2, 6885, 6883, 3, 2, 2, 2, 6885, 6886, 3, 2, 2, 2, 6886, 675, 3, 2, 2, 2, 6887, 6888, 7, 587, 2, 2, 6888, 6893, 5, 678, 340, 2, 6889, 6890, 7, 581, 2, 2, 6890, 6892, 5, 678, 340, 2, 6891, 6889, 3, 2, 2, 2, 6892, 6895, 3, 2, 2, 2, 6893, 6891, 3, 2, 2, 2, 6893, 6894, 3, 2, 2, 2, 6894, 6896, 3, 2, 2, 2, 6895, 6893, 3, 2, 2, 2, 6896, 6897, 7, 588, 2, 2, 6897, 677, 3, 2, 2, 2, 6898, 6900, 5, 528, 265, 2, 6899, 6901, 5, 512, 257, 2, 6900, 6899, 3, 2, 2, 2, 6900, 6901, 3, 2, 2, 2, 6901, 679, 3, 2, 2, 2, 6902, 6904, 5, 148, 75, 2, 6903, 6905, 5, 152, 77, 2, 6904, 6903, 3, 2, 2, 2, 6904, 6905, 3, 2, 2, 2, 6905, 6910, 3, 2, 2, 2, 6906, 6907, 7, 419, 2, 2, 6907, 6908, 7, 383, 2, 2, 6908, 6910, 5, 528, 265, 2, 6909, 6902, 3, 2, 2, 2, 6909, 6906, 3, 2, 2, 2, 6910, 681, 3, 2, 2, 2, 6911, 6912, 7, 395, 2, 2, 6912, 6929, 7, 153, 2, 2, 6913, 6914, 7, 395, 2, 2, 6914, 6915, 7, 274, 2, 2, 6915, 6916, 7, 230, 2, 2, 6916, 6921, 5, 688, 345, 2, 6917, 6918, 7, 581, 2, 2, 6918, 6920, 5, 688, 345, 2, 6919, 6917, 3, 2, 2, 2, 6920, 6923, 3, 2, 2, 2, 6921, 6919, 3, 2, 2, 2, 6921, 6922, 3, 2, 2, 2, 6922, 6926, 3, 2, 2, 2, 6923, 6921, 3, 2, 2, 2, 6924, 6925, 7, 442, 2, 2, 6925, 6927, 5, 560, 281, 2, 6926, 6924, 3, 2, 2, 2, 6926, 6927, 3, 2, 2, 2, 6927, 6929, 3, 2, 2, 2, 6928, 6911, 3, 2, 2, 2, 6928, 6913, 3, 2, 2, 2, 6929, 683, 3, 2, 2, 2, 6930, 6932, 5, 630, 316, 2, 6931, 6930, 3, 2, 2, 2, 6931, 6932, 3, 2, 2, 2, 6932, 6933, 3, 2, 2, 2, 6933, 6934, 7, 62, 2, 2, 6934, 6936, 7, 403, 2, 2, 6935, 6937, 7, 420, 2, 2, 6936, 6935, 3, 2, 2, 2, 6936, 6937, 3, 2, 2, 2, 6937, 6938, 3, 2, 2, 2, 6938, 6940, 5, 618, 310, 2, 6939, 6941, 7, 591, 2, 2, 6940, 6939, 3, 2, 2, 2, 6940, 6941, 3, 2, 2, 2, 6941, 6946, 3, 2, 2, 2, 6942, 6944, 7, 374, 2, 2, 6943, 6942, 3, 2, 2, 2, 6943, 6944, 3, 2, 2, 2, 6944, 6945, 3, 2, 2, 2, 6945, 6947, 5, 528, 265, 2, 6946, 6943, 3, 2, 2, 2, 6946, 6947, 3, 2, 2, 2, 6947, 6957, 3, 2, 2, 2, 6948, 6949, 7, 439, 2, 2, 6949, 6954, 5, 646, 324, 2, 6950, 6951, 7, 581, 2, 2, 6951, 6953, 5, 646, 324, 2, 6952, 6950, 3, 2, 2, 2, 6953, 6956, 3, 2, 2, 2, 6954, 6952, 3, 2, 2, 2, 6954, 6955, 3, 2, 2, 2, 6955, 6958, 3, 2, 2, 2, 6956, 6954, 3, 2, 2, 2, 6957, 6948, 3, 2, 2, 2, 6957, 6958, 3, 2, 2, 2, 6958, 6966, 3, 2, 2, 2, 6959, 6964, 7, 442, 2, 2, 6960, 6965, 5, 560, 281, 2, 6961, 6962, 7, 51, 2, 2, 6962, 6963, 7, 158, 2, 2, 6963, 6965, 5, 528, 265, 2, 6964, 6960, 3, 2, 2, 2, 6964, 6961, 3, 2, 2, 2, 6965, 6967, 3, 2, 2, 2, 6966, 6959, 3, 2, 2, 2, 6966, 6967, 3, 2, 2, 2, 6967, 6970, 3, 2, 2, 2, 6968, 6969, 7, 426, 2, 2, 6969, 6971, 5, 640, 321, 2, 6970, 6968, 3, 2, 2, 2, 6970, 6971, 3, 2, 2, 2, 6971, 685, 3, 2, 2, 2, 6972, 6974, 5, 630, 316, 2, 6973, 6972, 3, 2, 2, 2, 6973, 6974, 3, 2, 2, 2, 6974, 6975, 3, 2, 2, 2, 6975, 6977, 7, 274, 2, 2, 6976, 6978, 7, 420, 2, 2, 6977, 6976, 3, 2, 2, 2, 6977, 6978, 3, 2, 2, 2, 6978, 6979, 3, 2, 2, 2, 6979, 6981, 5, 618, 310, 2, 6980, 6982, 7, 591, 2, 2, 6981, 6980, 3, 2, 2, 2, 6981, 6982, 3, 2, 2, 2, 6982, 6987, 3, 2, 2, 2, 6983, 6985, 7, 374, 2, 2, 6984, 6983, 3, 2, 2, 2, 6984, 6985, 3, 2, 2, 2, 6985, 6986, 3, 2, 2, 2, 6986, 6988, 5, 528, 265, 2, 6987, 6984, 3, 2, 2, 2, 6987, 6988, 3, 2, 2, 2, 6988, 6989, 3, 2, 2, 2, 6989, 6990, 7, 230, 2, 2, 6990, 6995, 5, 688, 345, 2, 6991, 6992, 7, 581, 2, 2, 6992, 6994, 5, 688, 345, 2, 6993, 6991, 3, 2, 2, 2, 6994, 6997, 3, 2, 2, 2, 6995, 6993, 3, 2, 2, 2, 6995, 6996, 3, 2, 2, 2, 6996, 7007, 3, 2, 2, 2, 6997, 6995, 3, 2, 2, 2, 6998, 6999, 7, 403, 2, 2, 6999, 7004, 5, 646, 324, 2, 7000, 7001, 7, 581, 2, 2, 7001, 7003, 5, 646, 324, 2, 7002, 7000, 3, 2, 2, 2, 7003, 7006, 3, 2, 2, 2, 7004, 7002, 3, 2, 2, 2, 7004, 7005, 3, 2, 2, 2, 7005, 7008, 3, 2, 2, 2, 7006, 7004, 3, 2, 2, 2, 7007, 6998, 3, 2, 2, 2, 7007, 7008, 3, 2, 2, 2, 7008, 7016, 3, 2, 2, 2, 7009, 7014, 7, 442, 2, 2, 7010, 7015, 5, 560, 281, 2, 7011, 7012, 7, 51, 2, 2, 7012, 7013, 7, 158, 2, 2, 7013, 7015, 5, 528, 265, 2, 7014, 7010, 3, 2, 2, 2, 7014, 7011, 3, 2, 2, 2, 7015, 7017, 3, 2, 2, 2, 7016, 7009, 3, 2, 2, 2, 7016, 7017, 3, 2, 2, 2, 7017, 7020, 3, 2, 2, 2, 7018, 7019, 7, 426, 2, 2, 7019, 7021, 5, 640, 321, 2, 7020, 7018, 3, 2, 2, 2, 7020, 7021, 3, 2, 2, 2, 7021, 687, 3, 2, 2, 2, 7022, 7023, 5, 678, 340, 2, 7023, 7026, 7, 578, 2, 2, 7024, 7027, 5, 560, 281, 2, 7025, 7027, 7, 391, 2, 2, 7026, 7024, 3, 2, 2, 2, 7026, 7025, 3, 2, 2, 2, 7027, 7062, 3, 2, 2, 2, 7028, 7029, 7, 587, 2, 2, 7029, 7034, 5, 678, 340, 2, 7030, 7031, 7, 581, 2, 2, 7031, 7033, 5, 678, 340, 2, 7032, 7030, 3, 2, 2, 2, 7033, 7036, 3, 2, 2, 2, 7034, 7032, 3, 2, 2, 2, 7034, 7035, 3, 2, 2, 2, 7035, 7037, 3, 2, 2, 2, 7036, 7034, 3, 2, 2, 2, 7037, 7038, 7, 588, 2, 2, 7038, 7040, 7, 578, 2, 2, 7039, 7041, 7, 324, 2, 2, 7040, 7039, 3, 2, 2, 2, 7040, 7041, 3, 2, 2, 2, 7041, 7059, 3, 2, 2, 2, 7042, 7045, 7, 587, 2, 2, 7043, 7046, 5, 560, 281, 2, 7044, 7046, 7, 391, 2, 2, 7045, 7043, 3, 2, 2, 2, 7045, 7044, 3, 2, 2, 2, 7046, 7054, 3, 2, 2, 2, 7047, 7050, 7, 581, 2, 2, 7048, 7051, 5, 560, 281, 2, 7049, 7051, 7, 391, 2, 2, 7050, 7048, 3, 2, 2, 2, 7050, 7049, 3, 2, 2, 2, 7051, 7053, 3, 2, 2, 2, 7052, 7047, 3, 2, 2, 2, 7053, 7056, 3, 2, 2, 2, 7054, 7052, 3, 2, 2, 2, 7054, 7055, 3, 2, 2, 2, 7055, 7057, 3, 2, 2, 2, 7056, 7054, 3, 2, 2, 2, 7057, 7060, 7, 588, 2, 2, 7058, 7060, 5, 622, 312, 2, 7059, 7042, 3, 2, 2, 2, 7059, 7058, 3, 2, 2, 2, 7060, 7062, 3, 2, 2, 2, 7061, 7022, 3, 2, 2, 2, 7061, 7028, 3, 2, 2, 2, 7062, 689, 3, 2, 2, 2, 7063, 7064, 7, 154, 2, 2, 7064, 7067, 5, 528, 265, 2, 7065, 7066, 7, 581, 2, 2, 7066, 7068, 5, 326, 164, 2, 7067, 7065, 3, 2, 2, 2, 7067, 7068, 3, 2, 2, 2, 7068, 691, 3, 2, 2, 2, 7069, 7071, 7, 263, 2, 2, 7070, 7072, 7, 431, 2, 2, 7071, 7070, 3, 2, 2, 2, 7071, 7072, 3, 2, 2, 2, 7072, 7073, 3, 2, 2, 2, 7073, 7078, 5, 390, 196, 2, 7074, 7075, 7, 581, 2, 2, 7075, 7077, 5, 390, 196, 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, 7083, 3, 2, 2, 2, 7080, 7078, 3, 2, 2, 2, 7081, 7082, 9, 99, 2, 2, 7082, 7084, 7, 104, 2, 2, 7083, 7081, 3, 2, 2, 2, 7083, 7084, 3, 2, 2, 2, 7084, 7086, 3, 2, 2, 2, 7085, 7087, 5, 504, 253, 2, 7086, 7085, 3, 2, 2, 2, 7086, 7087, 3, 2, 2, 2, 7087, 693, 3, 2, 2, 2, 7088, 7093, 5, 528, 265, 2, 7089, 7090, 7, 581, 2, 2, 7090, 7092, 5, 528, 265, 2, 7091, 7089, 3, 2, 2, 2, 7092, 7095, 3, 2, 2, 2, 7093, 7091, 3, 2, 2, 2, 7093, 7094, 3, 2, 2, 2, 7094, 695, 3, 2, 2, 2, 7095, 7093, 3, 2, 2, 2, 7096, 7102, 7, 395, 2, 2, 7097, 7100, 7, 126, 2, 2, 7098, 7101, 5, 528, 265, 2, 7099, 7101, 5, 326, 164, 2, 7100, 7098, 3, 2, 2, 2, 7100, 7099, 3, 2, 2, 2, 7101, 7103, 3, 2, 2, 2, 7102, 7097, 3, 2, 2, 2, 7102, 7103, 3, 2, 2, 2, 7103, 7104, 3, 2, 2, 2, 7104, 7113, 5, 326, 164, 2, 7105, 7106, 7, 395, 2, 2, 7106, 7107, 5, 326, 164, 2, 7107, 7110, 7, 126, 2, 2, 7108, 7111, 5, 528, 265, 2, 7109, 7111, 5, 326, 164, 2, 7110, 7108, 3, 2, 2, 2, 7110, 7109, 3, 2, 2, 2, 7111, 7113, 3, 2, 2, 2, 7112, 7096, 3, 2, 2, 2, 7112, 7105, 3, 2, 2, 2, 7113, 697, 3, 2, 2, 2, 7114, 7115, 7, 606, 2, 2, 7115, 7118, 5, 528, 265, 2, 7116, 7119, 5, 528, 265, 2, 7117, 7119, 5, 576, 289, 2, 7118, 7116, 3, 2, 2, 2, 7118, 7117, 3, 2, 2, 2, 7119, 699, 3, 2, 2, 2, 7120, 7122, 5, 702, 352, 2, 7121, 7120, 3, 2, 2, 2, 7121, 7122, 3, 2, 2, 2, 7122, 7124, 3, 2, 2, 2, 7123, 7125, 5, 704, 353, 2, 7124, 7123, 3, 2, 2, 2, 7124, 7125, 3, 2, 2, 2, 7125, 7126, 3, 2, 2, 2, 7126, 7127, 7, 21, 2, 2, 7127, 7129, 5, 716, 359, 2, 7128, 7130, 5, 714, 358, 2, 7129, 7128, 3, 2, 2, 2, 7129, 7130, 3, 2, 2, 2, 7130, 7131, 3, 2, 2, 2, 7131, 7133, 7, 397, 2, 2, 7132, 7134, 5, 528, 265, 2, 7133, 7132, 3, 2, 2, 2, 7133, 7134, 3, 2, 2, 2, 7134, 701, 3, 2, 2, 2, 7135, 7136, 7, 603, 2, 2, 7136, 7137, 5, 528, 265, 2, 7137, 7138, 7, 604, 2, 2, 7138, 703, 3, 2, 2, 2, 7139, 7143, 7, 58, 2, 2, 7140, 7142, 5, 706, 354, 2, 7141, 7140, 3, 2, 2, 2, 7142, 7145, 3, 2, 2, 2, 7143, 7141, 3, 2, 2, 2, 7143, 7144, 3, 2, 2, 2, 7144, 705, 3, 2, 2, 2, 7145, 7143, 3, 2, 2, 2, 7146, 7148, 7, 58, 2, 2, 7147, 7146, 3, 2, 2, 2, 7148, 7151, 3, 2, 2, 2, 7149, 7147, 3, 2, 2, 2, 7149, 7150, 3, 2, 2, 2, 7150, 7152, 3, 2, 2, 2, 7151, 7149, 3, 2, 2, 2, 7152, 7153, 5, 528, 265, 2, 7153, 7154, 5, 708, 355, 2, 7154, 7155, 7, 580, 2, 2, 7155, 707, 3, 2, 2, 2, 7156, 7158, 7, 546, 2, 2, 7157, 7156, 3, 2, 2, 2, 7157, 7158, 3, 2, 2, 2, 7158, 7159, 3, 2, 2, 2, 7159, 7161, 5, 712, 357, 2, 7160, 7162, 5, 506, 254, 2, 7161, 7160, 3, 2, 2, 2, 7161, 7162, 3, 2, 2, 2, 7162, 7165, 3, 2, 2, 2, 7163, 7164, 7, 416, 2, 2, 7164, 7166, 7, 417, 2, 2, 7165, 7163, 3, 2, 2, 2, 7165, 7166, 3, 2, 2, 2, 7166, 7169, 3, 2, 2, 2, 7167, 7168, 9, 100, 2, 2, 7168, 7170, 5, 560, 281, 2, 7169, 7167, 3, 2, 2, 2, 7169, 7170, 3, 2, 2, 2, 7170, 7193, 3, 2, 2, 2, 7171, 7172, 7, 544, 2, 2, 7172, 7175, 7, 401, 2, 2, 7173, 7176, 5, 528, 265, 2, 7174, 7176, 7, 612, 2, 2, 7175, 7173, 3, 2, 2, 2, 7175, 7174, 3, 2, 2, 2, 7176, 7193, 3, 2, 2, 2, 7177, 7179, 7, 152, 2, 2, 7178, 7177, 3, 2, 2, 2, 7178, 7179, 3, 2, 2, 2, 7179, 7180, 3, 2, 2, 2, 7180, 7182, 7, 221, 2, 2, 7181, 7178, 3, 2, 2, 2, 7181, 7182, 3, 2, 2, 2, 7182, 7183, 3, 2, 2, 2, 7183, 7188, 7, 52, 2, 2, 7184, 7185, 7, 587, 2, 2, 7185, 7186, 5, 710, 356, 2, 7186, 7187, 7, 588, 2, 2, 7187, 7189, 3, 2, 2, 2, 7188, 7184, 3, 2, 2, 2, 7188, 7189, 3, 2, 2, 2, 7189, 7190, 3, 2, 2, 2, 7190, 7191, 9, 101, 2, 2, 7191, 7193, 5, 624, 313, 2, 7192, 7157, 3, 2, 2, 2, 7192, 7171, 3, 2, 2, 2, 7192, 7181, 3, 2, 2, 2, 7193, 709, 3, 2, 2, 2, 7194, 7195, 5, 528, 265, 2, 7195, 7202, 5, 548, 275, 2, 7196, 7197, 7, 581, 2, 2, 7197, 7198, 5, 528, 265, 2, 7198, 7199, 5, 548, 275, 2, 7199, 7201, 3, 2, 2, 2, 7200, 7196, 3, 2, 2, 2, 7201, 7204, 3, 2, 2, 2, 7202, 7200, 3, 2, 2, 2, 7202, 7203, 3, 2, 2, 2, 7203, 711, 3, 2, 2, 2, 7204, 7202, 3, 2, 2, 2, 7205, 7215, 5, 548, 275, 2, 7206, 7207, 5, 618, 310, 2, 7207, 7208, 7, 593, 2, 2, 7208, 7209, 7, 265, 2, 2, 7209, 7215, 3, 2, 2, 2, 7210, 7211, 5, 544, 273, 2, 7211, 7212, 7, 593, 2, 2, 7212, 7213, 7, 571, 2, 2, 7213, 7215, 3, 2, 2, 2, 7214, 7205, 3, 2, 2, 2, 7214, 7206, 3, 2, 2, 2, 7214, 7210, 3, 2, 2, 2, 7215, 713, 3, 2, 2, 2, 7216, 7222, 7, 555, 2, 2, 7217, 7218, 7, 441, 2, 2, 7218, 7219, 5, 560, 281, 2, 7219, 7220, 7, 432, 2, 2, 7220, 7221, 5, 716, 359, 2, 7221, 7223, 3, 2, 2, 2, 7222, 7217, 3, 2, 2, 2, 7223, 7224, 3, 2, 2, 2, 7224, 7222, 3, 2, 2, 2, 7224, 7225, 3, 2, 2, 2, 7225, 715, 3, 2, 2, 2, 7226, 7227, 5, 718, 360, 2, 7227, 7228, 7, 580, 2, 2, 7228, 7230, 3, 2, 2, 2, 7229, 7226, 3, 2, 2, 2, 7230, 7233, 3, 2, 2, 2, 7231, 7229, 3, 2, 2, 2, 7231, 7232, 3, 2, 2, 2, 7232, 717, 3, 2, 2, 2, 7233, 7231, 3, 2, 2, 2, 7234, 7244, 5, 700, 351, 2, 7235, 7244, 5, 720, 361, 2, 7236, 7244, 5, 732, 367, 2, 7237, 7244, 5, 738, 370, 2, 7238, 7244, 5, 734, 368, 2, 7239, 7244, 5, 740, 371, 2, 7240, 7244, 5, 60, 31, 2, 7241, 7244, 5, 760, 381, 2, 7242, 7244, 5, 30, 16, 2, 7243, 7234, 3, 2, 2, 2, 7243, 7235, 3, 2, 2, 2, 7243, 7236, 3, 2, 2, 2, 7243, 7237, 3, 2, 2, 2, 7243, 7238, 3, 2, 2, 2, 7243, 7239, 3, 2, 2, 2, 7243, 7240, 3, 2, 2, 2, 7243, 7241, 3, 2, 2, 2, 7243, 7242, 3, 2, 2, 2, 7244, 719, 3, 2, 2, 2, 7245, 7263, 5, 728, 365, 2, 7246, 7247, 7, 565, 2, 2, 7247, 7263, 5, 726, 364, 2, 7248, 7250, 7, 557, 2, 2, 7249, 7251, 9, 102, 2, 2, 7250, 7249, 3, 2, 2, 2, 7250, 7251, 3, 2, 2, 2, 7251, 7252, 3, 2, 2, 2, 7252, 7253, 7, 550, 2, 2, 7253, 7258, 5, 724, 363, 2, 7254, 7255, 7, 581, 2, 2, 7255, 7257, 5, 724, 363, 2, 7256, 7254, 3, 2, 2, 2, 7257, 7260, 3, 2, 2, 2, 7258, 7256, 3, 2, 2, 2, 7258, 7259, 3, 2, 2, 2, 7259, 7263, 3, 2, 2, 2, 7260, 7258, 3, 2, 2, 2, 7261, 7263, 7, 417, 2, 2, 7262, 7245, 3, 2, 2, 2, 7262, 7246, 3, 2, 2, 2, 7262, 7248, 3, 2, 2, 2, 7262, 7261, 3, 2, 2, 2, 7263, 721, 3, 2, 2, 2, 7264, 7267, 5, 618, 310, 2, 7265, 7267, 7, 612, 2, 2, 7266, 7264, 3, 2, 2, 2, 7266, 7265, 3, 2, 2, 2, 7267, 7274, 3, 2, 2, 2, 7268, 7269, 7, 599, 2, 2, 7269, 7270, 5, 560, 281, 2, 7270, 7271, 7, 600, 2, 2, 7271, 7273, 3, 2, 2, 2, 7272, 7268, 3, 2, 2, 2, 7273, 7276, 3, 2, 2, 2, 7274, 7272, 3, 2, 2, 2, 7274, 7275, 3, 2, 2, 2, 7275, 723, 3, 2, 2, 2, 7276, 7274, 3, 2, 2, 2, 7277, 7278, 5, 722, 362, 2, 7278, 7279, 9, 103, 2, 2, 7279, 7280, 5, 528, 265, 2, 7280, 725, 3, 2, 2, 2, 7281, 7294, 5, 620, 311, 2, 7282, 7283, 7, 419, 2, 2, 7283, 7284, 7, 587, 2, 2, 7284, 7289, 5, 560, 281, 2, 7285, 7286, 7, 581, 2, 2, 7286, 7288, 5, 560, 281, 2, 7287, 7285, 3, 2, 2, 2, 7288, 7291, 3, 2, 2, 2, 7289, 7287, 3, 2, 2, 2, 7289, 7290, 3, 2, 2, 2, 7290, 7292, 3, 2, 2, 2, 7291, 7289, 3, 2, 2, 2, 7292, 7293, 7, 588, 2, 2, 7293, 7295, 3, 2, 2, 2, 7294, 7282, 3, 2, 2, 2, 7294, 7295, 3, 2, 2, 2, 7295, 7297, 3, 2, 2, 2, 7296, 7281, 3, 2, 2, 2, 7296, 7297, 3, 2, 2, 2, 7297, 7298, 3, 2, 2, 2, 7298, 7308, 5, 640, 321, 2, 7299, 7300, 7, 403, 2, 2, 7300, 7305, 5, 646, 324, 2, 7301, 7302, 7, 581, 2, 2, 7302, 7304, 5, 646, 324, 2, 7303, 7301, 3, 2, 2, 2, 7304, 7307, 3, 2, 2, 2, 7305, 7303, 3, 2, 2, 2, 7305, 7306, 3, 2, 2, 2, 7306, 7309, 3, 2, 2, 2, 7307, 7305, 3, 2, 2, 2, 7308, 7299, 3, 2, 2, 2, 7308, 7309, 3, 2, 2, 2, 7309, 7312, 3, 2, 2, 2, 7310, 7311, 7, 442, 2, 2, 7311, 7313, 5, 560, 281, 2, 7312, 7310, 3, 2, 2, 2, 7312, 7313, 3, 2, 2, 2, 7313, 7315, 3, 2, 2, 2, 7314, 7316, 5, 654, 328, 2, 7315, 7314, 3, 2, 2, 2, 7315, 7316, 3, 2, 2, 2, 7316, 7319, 3, 2, 2, 2, 7317, 7318, 7, 406, 2, 2, 7318, 7320, 5, 560, 281, 2, 7319, 7317, 3, 2, 2, 2, 7319, 7320, 3, 2, 2, 2, 7320, 7335, 3, 2, 2, 2, 7321, 7322, 7, 443, 2, 2, 7322, 7323, 5, 528, 265, 2, 7323, 7324, 7, 374, 2, 2, 7324, 7332, 5, 606, 304, 2, 7325, 7326, 7, 581, 2, 2, 7326, 7327, 5, 528, 265, 2, 7327, 7328, 7, 374, 2, 2, 7328, 7329, 5, 606, 304, 2, 7329, 7331, 3, 2, 2, 2, 7330, 7325, 3, 2, 2, 2, 7331, 7334, 3, 2, 2, 2, 7332, 7330, 3, 2, 2, 2, 7332, 7333, 3, 2, 2, 2, 7333, 7336, 3, 2, 2, 2, 7334, 7332, 3, 2, 2, 2, 7335, 7321, 3, 2, 2, 2, 7335, 7336, 3, 2, 2, 2, 7336, 7342, 3, 2, 2, 2, 7337, 7339, 9, 94, 2, 2, 7338, 7340, 5, 620, 311, 2, 7339, 7338, 3, 2, 2, 2, 7339, 7340, 3, 2, 2, 2, 7340, 7341, 3, 2, 2, 2, 7341, 7343, 5, 634, 318, 2, 7342, 7337, 3, 2, 2, 2, 7342, 7343, 3, 2, 2, 2, 7343, 7347, 3, 2, 2, 2, 7344, 7346, 5, 626, 314, 2, 7345, 7344, 3, 2, 2, 2, 7346, 7349, 3, 2, 2, 2, 7347, 7345, 3, 2, 2, 2, 7347, 7348, 3, 2, 2, 2, 7348, 727, 3, 2, 2, 2, 7349, 7347, 3, 2, 2, 2, 7350, 7351, 5, 722, 362, 2, 7351, 7354, 9, 103, 2, 2, 7352, 7355, 5, 628, 315, 2, 7353, 7355, 5, 726, 364, 2, 7354, 7352, 3, 2, 2, 2, 7354, 7353, 3, 2, 2, 2, 7355, 729, 3, 2, 2, 2, 7356, 7357, 7, 84, 2, 2, 7357, 7359, 5, 560, 281, 2, 7358, 7360, 5, 754, 378, 2, 7359, 7358, 3, 2, 2, 2, 7359, 7360, 3, 2, 2, 2, 7360, 731, 3, 2, 2, 2, 7361, 7368, 5, 748, 375, 2, 7362, 7363, 7, 24, 2, 2, 7363, 7368, 5, 582, 292, 2, 7364, 7368, 5, 756, 379, 2, 7365, 7368, 5, 758, 380, 2, 7366, 7368, 5, 750, 376, 2, 7367, 7361, 3, 2, 2, 2, 7367, 7362, 3, 2, 2, 2, 7367, 7364, 3, 2, 2, 2, 7367, 7365, 3, 2, 2, 2, 7367, 7366, 3, 2, 2, 2, 7368, 733, 3, 2, 2, 2, 7369, 7370, 7, 564, 2, 2, 7370, 7375, 5, 722, 362, 2, 7371, 7373, 7, 152, 2, 2, 7372, 7371, 3, 2, 2, 2, 7372, 7373, 3, 2, 2, 2, 7373, 7374, 3, 2, 2, 2, 7374, 7376, 7, 221, 2, 2, 7375, 7372, 3, 2, 2, 2, 7375, 7376, 3, 2, 2, 2, 7376, 7377, 3, 2, 2, 2, 7377, 7378, 7, 401, 2, 2, 7378, 7379, 5, 760, 381, 2, 7379, 7414, 3, 2, 2, 2, 7380, 7381, 7, 564, 2, 2, 7381, 7393, 5, 722, 362, 2, 7382, 7383, 7, 587, 2, 2, 7383, 7388, 5, 736, 369, 2, 7384, 7385, 7, 581, 2, 2, 7385, 7387, 5, 736, 369, 2, 7386, 7384, 3, 2, 2, 2, 7387, 7390, 3, 2, 2, 2, 7388, 7386, 3, 2, 2, 2, 7388, 7389, 3, 2, 2, 2, 7389, 7391, 3, 2, 2, 2, 7390, 7388, 3, 2, 2, 2, 7391, 7392, 7, 588, 2, 2, 7392, 7394, 3, 2, 2, 2, 7393, 7382, 3, 2, 2, 2, 7393, 7394, 3, 2, 2, 2, 7394, 7414, 3, 2, 2, 2, 7395, 7397, 7, 400, 2, 2, 7396, 7398, 5, 58, 30, 2, 7397, 7396, 3, 2, 2, 2, 7397, 7398, 3, 2, 2, 2, 7398, 7400, 3, 2, 2, 2, 7399, 7401, 9, 7, 2, 2, 7400, 7399, 3, 2, 2, 2, 7400, 7401, 3, 2, 2, 2, 7401, 7402, 3, 2, 2, 2, 7402, 7414, 5, 722, 362, 2, 7403, 7405, 7, 147, 2, 2, 7404, 7406, 5, 58, 30, 2, 7405, 7404, 3, 2, 2, 2, 7405, 7406, 3, 2, 2, 2, 7406, 7408, 3, 2, 2, 2, 7407, 7409, 9, 7, 2, 2, 7408, 7407, 3, 2, 2, 2, 7408, 7409, 3, 2, 2, 2, 7409, 7410, 3, 2, 2, 2, 7410, 7414, 5, 722, 362, 2, 7411, 7412, 7, 33, 2, 2, 7412, 7414, 5, 722, 362, 2, 7413, 7369, 3, 2, 2, 2, 7413, 7380, 3, 2, 2, 2, 7413, 7395, 3, 2, 2, 2, 7413, 7403, 3, 2, 2, 2, 7413, 7411, 3, 2, 2, 2, 7414, 735, 3, 2, 2, 2, 7415, 7416, 5, 528, 265, 2, 7416, 7417, 7, 602, 2, 2, 7417, 7419, 3, 2, 2, 2, 7418, 7415, 3, 2, 2, 2, 7418, 7419, 3, 2, 2, 2, 7419, 7420, 3, 2, 2, 2, 7420, 7421, 5, 560, 281, 2, 7421, 737, 3, 2, 2, 2, 7422, 7428, 9, 104, 2, 2, 7423, 7425, 7, 371, 2, 2, 7424, 7426, 7, 152, 2, 2, 7425, 7424, 3, 2, 2, 2, 7425, 7426, 3, 2, 2, 2, 7426, 7427, 3, 2, 2, 2, 7427, 7429, 7, 29, 2, 2, 7428, 7423, 3, 2, 2, 2, 7428, 7429, 3, 2, 2, 2, 7429, 7432, 3, 2, 2, 2, 7430, 7432, 5, 24, 13, 2, 7431, 7422, 3, 2, 2, 2, 7431, 7430, 3, 2, 2, 2, 7432, 739, 3, 2, 2, 2, 7433, 7435, 7, 567, 2, 2, 7434, 7436, 5, 742, 372, 2, 7435, 7434, 3, 2, 2, 2, 7435, 7436, 3, 2, 2, 2, 7436, 7445, 3, 2, 2, 2, 7437, 7442, 5, 326, 164, 2, 7438, 7439, 7, 581, 2, 2, 7439, 7441, 5, 560, 281, 2, 7440, 7438, 3, 2, 2, 2, 7441, 7444, 3, 2, 2, 2, 7442, 7440, 3, 2, 2, 2, 7442, 7443, 3, 2, 2, 2, 7443, 7446, 3, 2, 2, 2, 7444, 7442, 3, 2, 2, 2, 7445, 7437, 3, 2, 2, 2, 7445, 7446, 3, 2, 2, 2, 7446, 7448, 3, 2, 2, 2, 7447, 7449, 5, 744, 373, 2, 7448, 7447, 3, 2, 2, 2, 7448, 7449, 3, 2, 2, 2, 7449, 7474, 3, 2, 2, 2, 7450, 7452, 7, 567, 2, 2, 7451, 7453, 5, 742, 372, 2, 7452, 7451, 3, 2, 2, 2, 7452, 7453, 3, 2, 2, 2, 7453, 7454, 3, 2, 2, 2, 7454, 7456, 5, 528, 265, 2, 7455, 7457, 5, 744, 373, 2, 7456, 7455, 3, 2, 2, 2, 7456, 7457, 3, 2, 2, 2, 7457, 7474, 3, 2, 2, 2, 7458, 7460, 7, 567, 2, 2, 7459, 7461, 5, 742, 372, 2, 7460, 7459, 3, 2, 2, 2, 7460, 7461, 3, 2, 2, 2, 7461, 7462, 3, 2, 2, 2, 7462, 7463, 7, 573, 2, 2, 7463, 7465, 5, 326, 164, 2, 7464, 7466, 5, 744, 373, 2, 7465, 7464, 3, 2, 2, 2, 7465, 7466, 3, 2, 2, 2, 7466, 7474, 3, 2, 2, 2, 7467, 7468, 7, 545, 2, 2, 7468, 7471, 5, 560, 281, 2, 7469, 7470, 7, 581, 2, 2, 7470, 7472, 5, 560, 281, 2, 7471, 7469, 3, 2, 2, 2, 7471, 7472, 3, 2, 2, 2, 7472, 7474, 3, 2, 2, 2, 7473, 7433, 3, 2, 2, 2, 7473, 7450, 3, 2, 2, 2, 7473, 7458, 3, 2, 2, 2, 7473, 7467, 3, 2, 2, 2, 7474, 741, 3, 2, 2, 2, 7475, 7476, 9, 105, 2, 2, 7476, 743, 3, 2, 2, 2, 7477, 7478, 7, 439, 2, 2, 7478, 7479, 5, 746, 374, 2, 7479, 7480, 7, 578, 2, 2, 7480, 7488, 5, 560, 281, 2, 7481, 7482, 7, 581, 2, 2, 7482, 7483, 5, 746, 374, 2, 7483, 7484, 7, 578, 2, 2, 7484, 7485, 5, 560, 281, 2, 7485, 7487, 3, 2, 2, 2, 7486, 7481, 3, 2, 2, 2, 7487, 7490, 3, 2, 2, 2, 7488, 7486, 3, 2, 2, 2, 7488, 7489, 3, 2, 2, 2, 7489, 745, 3, 2, 2, 2, 7490, 7488, 3, 2, 2, 2, 7491, 7492, 9, 106, 2, 2, 7492, 747, 3, 2, 2, 2, 7493, 7495, 7, 569, 2, 2, 7494, 7496, 5, 726, 364, 2, 7495, 7494, 3, 2, 2, 2, 7495, 7496, 3, 2, 2, 2, 7496, 7504, 3, 2, 2, 2, 7497, 7498, 7, 569, 2, 2, 7498, 7499, 7, 151, 2, 2, 7499, 7504, 5, 560, 281, 2, 7500, 7501, 7, 569, 2, 2, 7501, 7502, 7, 566, 2, 2, 7502, 7504, 5, 760, 381, 2, 7503, 7493, 3, 2, 2, 2, 7503, 7497, 3, 2, 2, 2, 7503, 7500, 3, 2, 2, 2, 7504, 749, 3, 2, 2, 2, 7505, 7507, 5, 702, 352, 2, 7506, 7505, 3, 2, 2, 2, 7506, 7507, 3, 2, 2, 2, 7507, 7509, 3, 2, 2, 2, 7508, 7510, 5, 752, 377, 2, 7509, 7508, 3, 2, 2, 2, 7509, 7510, 3, 2, 2, 2, 7510, 7511, 3, 2, 2, 2, 7511, 7512, 7, 561, 2, 2, 7512, 7513, 5, 716, 359, 2, 7513, 7514, 7, 397, 2, 2, 7514, 7516, 7, 561, 2, 2, 7515, 7517, 5, 528, 265, 2, 7516, 7515, 3, 2, 2, 2, 7516, 7517, 3, 2, 2, 2, 7517, 7527, 3, 2, 2, 2, 7518, 7520, 9, 107, 2, 2, 7519, 7521, 5, 528, 265, 2, 7520, 7519, 3, 2, 2, 2, 7520, 7521, 3, 2, 2, 2, 7521, 7524, 3, 2, 2, 2, 7522, 7523, 7, 441, 2, 2, 7523, 7525, 5, 560, 281, 2, 7524, 7522, 3, 2, 2, 2, 7524, 7525, 3, 2, 2, 2, 7525, 7527, 3, 2, 2, 2, 7526, 7506, 3, 2, 2, 2, 7526, 7518, 3, 2, 2, 2, 7527, 751, 3, 2, 2, 2, 7528, 7529, 7, 576, 2, 2, 7529, 7576, 5, 560, 281, 2, 7530, 7531, 7, 401, 2, 2, 7531, 7532, 5, 528, 265, 2, 7532, 7534, 7, 407, 2, 2, 7533, 7535, 7, 570, 2, 2, 7534, 7533, 3, 2, 2, 2, 7534, 7535, 3, 2, 2, 2, 7535, 7536, 3, 2, 2, 2, 7536, 7537, 5, 560, 281, 2, 7537, 7538, 7, 605, 2, 2, 7538, 7541, 5, 560, 281, 2, 7539, 7540, 7, 22, 2, 2, 7540, 7542, 5, 560, 281, 2, 7541, 7539, 3, 2, 2, 2, 7541, 7542, 3, 2, 2, 2, 7542, 7576, 3, 2, 2, 2, 7543, 7544, 7, 401, 2, 2, 7544, 7545, 5, 694, 348, 2, 7545, 7546, 7, 407, 2, 2, 7546, 7547, 5, 760, 381, 2, 7547, 7576, 3, 2, 2, 2, 7548, 7549, 7, 401, 2, 2, 7549, 7550, 5, 528, 265, 2, 7550, 7551, 7, 407, 2, 2, 7551, 7563, 5, 528, 265, 2, 7552, 7553, 7, 587, 2, 2, 7553, 7558, 5, 736, 369, 2, 7554, 7555, 7, 581, 2, 2, 7555, 7557, 5, 736, 369, 2, 7556, 7554, 3, 2, 2, 2, 7557, 7560, 3, 2, 2, 2, 7558, 7556, 3, 2, 2, 2, 7558, 7559, 3, 2, 2, 2, 7559, 7561, 3, 2, 2, 2, 7560, 7558, 3, 2, 2, 2, 7561, 7562, 7, 588, 2, 2, 7562, 7564, 3, 2, 2, 2, 7563, 7552, 3, 2, 2, 2, 7563, 7564, 3, 2, 2, 2, 7564, 7576, 3, 2, 2, 2, 7565, 7566, 7, 556, 2, 2, 7566, 7569, 5, 694, 348, 2, 7567, 7568, 7, 572, 2, 2, 7568, 7570, 7, 610, 2, 2, 7569, 7567, 3, 2, 2, 2, 7569, 7570, 3, 2, 2, 2, 7570, 7571, 3, 2, 2, 2, 7571, 7572, 7, 407, 2, 2, 7572, 7573, 7, 373, 2, 2, 7573, 7574, 5, 560, 281, 2, 7574, 7576, 3, 2, 2, 2, 7575, 7528, 3, 2, 2, 2, 7575, 7530, 3, 2, 2, 2, 7575, 7543, 3, 2, 2, 2, 7575, 7548, 3, 2, 2, 2, 7575, 7565, 3, 2, 2, 2, 7576, 753, 3, 2, 2, 2, 7577, 7578, 7, 439, 2, 2, 7578, 7583, 5, 560, 281, 2, 7579, 7580, 7, 581, 2, 2, 7580, 7582, 5, 560, 281, 2, 7581, 7579, 3, 2, 2, 2, 7582, 7585, 3, 2, 2, 2, 7583, 7581, 3, 2, 2, 2, 7583, 7584, 3, 2, 2, 2, 7584, 755, 3, 2, 2, 2, 7585, 7583, 3, 2, 2, 2, 7586, 7587, 7, 105, 2, 2, 7587, 7588, 5, 560, 281, 2, 7588, 7589, 7, 432, 2, 2, 7589, 7597, 5, 716, 359, 2, 7590, 7591, 9, 108, 2, 2, 7591, 7592, 5, 560, 281, 2, 7592, 7593, 7, 432, 2, 2, 7593, 7594, 5, 716, 359, 2, 7594, 7596, 3, 2, 2, 2, 7595, 7590, 3, 2, 2, 2, 7596, 7599, 3, 2, 2, 2, 7597, 7595, 3, 2, 2, 2, 7597, 7598, 3, 2, 2, 2, 7598, 7602, 3, 2, 2, 2, 7599, 7597, 3, 2, 2, 2, 7600, 7601, 7, 396, 2, 2, 7601, 7603, 5, 716, 359, 2, 7602, 7600, 3, 2, 2, 2, 7602, 7603, 3, 2, 2, 2, 7603, 7604, 3, 2, 2, 2, 7604, 7605, 7, 397, 2, 2, 7605, 7606, 7, 105, 2, 2, 7606, 757, 3, 2, 2, 2, 7607, 7609, 7, 378, 2, 2, 7608, 7610, 5, 560, 281, 2, 7609, 7608, 3, 2, 2, 2, 7609, 7610, 3, 2, 2, 2, 7610, 7623, 3, 2, 2, 2, 7611, 7612, 7, 441, 2, 2, 7612, 7617, 5, 560, 281, 2, 7613, 7614, 7, 581, 2, 2, 7614, 7616, 5, 560, 281, 2, 7615, 7613, 3, 2, 2, 2, 7616, 7619, 3, 2, 2, 2, 7617, 7615, 3, 2, 2, 2, 7617, 7618, 3, 2, 2, 2, 7618, 7620, 3, 2, 2, 2, 7619, 7617, 3, 2, 2, 2, 7620, 7621, 7, 432, 2, 2, 7621, 7622, 5, 716, 359, 2, 7622, 7624, 3, 2, 2, 2, 7623, 7611, 3, 2, 2, 2, 7624, 7625, 3, 2, 2, 2, 7625, 7623, 3, 2, 2, 2, 7625, 7626, 3, 2, 2, 2, 7626, 7629, 3, 2, 2, 2, 7627, 7628, 7, 396, 2, 2, 7628, 7630, 5, 716, 359, 2, 7629, 7627, 3, 2, 2, 2, 7629, 7630, 3, 2, 2, 2, 7630, 7631, 3, 2, 2, 2, 7631, 7632, 7, 397, 2, 2, 7632, 7633, 7, 378, 2, 2, 7633, 759, 3, 2, 2, 2, 7634, 7639, 5, 16, 9, 2, 7635, 7639, 5, 730, 366, 2, 7636, 7639, 5, 40, 21, 2, 7637, 7639, 5, 32, 17, 2, 7638, 7634, 3, 2, 2, 2, 7638, 7635, 3, 2, 2, 2, 7638, 7636, 3, 2, 2, 2, 7638, 7637, 3, 2, 2, 2, 7639, 761, 3, 2, 2, 2, 1039, 763, 768, 775, 778, 782, 791, 801, 807, 811, 816, 823, 831, 837, 841, 847, 849, 856, 859, 863, 867, 870, 876, 882, 884, 892, 896, 900, 911, 918, 921, 925, 932, 939, 942, 953, 956, 962, 966, 969, 975, 985, 993, 1002, 1008, 1011, 1015, 1024, 1026, 1033, 1037, 1043, 1047, 1054, 1062, 1068, 1073, 1076, 1086, 1091, 1104, 1113, 1117, 1120, 1128, 1133, 1143, 1145, 1155, 1160, 1165, 1168, 1171, 1174, 1179, 1188, 1199, 1203, 1207, 1212, 1219, 1229, 1234, 1242, 1248, 1251, 1254, 1257, 1259, 1263, 1267, 1276, 1282, 1286, 1288, 1293, 1334, 1341, 1376, 1390, 1399, 1405, 1413, 1417, 1424, 1428, 1430, 1432, 1435, 1443, 1449, 1460, 1462, 1466, 1499, 1518, 1558, 1565, 1571, 1574, 1578, 1581, 1585, 1592, 1597, 1619, 1623, 1626, 1631, 1634, 1638, 1642, 1651, 1660, 1678, 1720, 1726, 1729, 1731, 1735, 1740, 1744, 1752, 1759, 1775, 1777, 1783, 1791, 1795, 1802, 1808, 1811, 1813, 1824, 1828, 1831, 1841, 1852, 1860, 1864, 1880, 1887, 1894, 1899, 1903, 1916, 1922, 1924, 1936, 1939, 1960, 1965, 1972, 1977, 1984, 1986, 1993, 2004, 2009, 2011, 2018, 2020, 2028, 2030, 2037, 2039, 2043, 2047, 2055, 2061, 2064, 2066, 2068, 2073, 2076, 2080, 2085, 2090, 2098, 2108, 2112, 2121, 2126, 2134, 2147, 2150, 2163, 2175, 2183, 2190, 2198, 2208, 2220, 2227, 2238, 2242, 2249, 2252, 2257, 2261, 2268, 2273, 2276, 2278, 2288, 2292, 2295, 2298, 2302, 2309, 2313, 2316, 2319, 2322, 2335, 2345, 2349, 2353, 2358, 2360, 2365, 2367, 2370, 2374, 2377, 2380, 2388, 2392, 2394, 2410, 2415, 2419, 2421, 2436, 2439, 2449, 2452, 2472, 2490, 2494, 2498, 2505, 2508, 2537, 2567, 2571, 2576, 2581, 2588, 2590, 2595, 2600, 2604, 2611, 2625, 2645, 2659, 2668, 2694, 2703, 2709, 2720, 2723, 2726, 2735, 2741, 2746, 2751, 2756, 2761, 2768, 2773, 2782, 2787, 2789, 2793, 2798, 2806, 2816, 2826, 2831, 2844, 2870, 2873, 2876, 2879, 2892, 2902, 2909, 2921, 2927, 2930, 2934, 2948, 2953, 2962, 2967, 2979, 2983, 2987, 2994, 2998, 3004, 3009, 3015, 3023, 3026, 3030, 3062, 3068, 3071, 3076, 3080, 3093, 3098, 3103, 3112, 3123, 3126, 3131, 3136, 3138, 3142, 3148, 3159, 3164, 3168, 3175, 3192, 3198, 3207, 3212, 3225, 3233, 3254, 3258, 3263, 3271, 3284, 3340, 3348, 3357, 3372, 3376, 3382, 3389, 3397, 3402, 3411, 3413, 3420, 3424, 3428, 3439, 3443, 3453, 3458, 3462, 3469, 3472, 3480, 3485, 3490, 3492, 3495, 3499, 3505, 3508, 3511, 3516, 3518, 3522, 3525, 3528, 3537, 3549, 3551, 3555, 3565, 3568, 3571, 3593, 3603, 3619, 3626, 3639, 3644, 3658, 3667, 3673, 3679, 3681, 3688, 3693, 3700, 3704, 3714, 3721, 3723, 3730, 3754, 3774, 3784, 3802, 3856, 3872, 3880, 3885, 3903, 3907, 3914, 3916, 3923, 3926, 3939, 3956, 3959, 3962, 3965, 3976, 3983, 3988, 3991, 3994, 3999, 4004, 4008, 4014, 4024, 4031, 4037, 4041, 4047, 4053, 4056, 4061, 4069, 4072, 4076, 4084, 4088, 4096, 4099, 4103, 4108, 4126, 4129, 4133, 4138, 4140, 4144, 4150, 4159, 4171, 4176, 4184, 4201, 4207, 4211, 4219, 4243, 4252, 4255, 4266, 4273, 4278, 4280, 4283, 4287, 4294, 4299, 4301, 4308, 4314, 4320, 4329, 4337, 4346, 4351, 4354, 4362, 4369, 4374, 4376, 4379, 4385, 4395, 4400, 4406, 4409, 4425, 4436, 4442, 4445, 4462, 4465, 4468, 4472, 4483, 4493, 4499, 4503, 4506, 4513, 4515, 4519, 4527, 4531, 4535, 4538, 4545, 4547, 4551, 4556, 4560, 4565, 4569, 4573, 4578, 4583, 4593, 4601, 4619, 4623, 4626, 4629, 4632, 4636, 4640, 4644, 4648, 4651, 4656, 4660, 4663, 4678, 4685, 4691, 4695, 4699, 4704, 4708, 4711, 4714, 4717, 4720, 4724, 4728, 4732, 4736, 4739, 4742, 4745, 4751, 4755, 4758, 4763, 4768, 4775, 4781, 4789, 4798, 4816, 4824, 4835, 4838, 4843, 4848, 4861, 4868, 4873, 4882, 4888, 4892, 4896, 4904, 4916, 4919, 4924, 4929, 4933, 4938, 4941, 4946, 4954, 4958, 4961, 4966, 4979, 4986, 4991, 4996, 5003, 5005, 5014, 5017, 5023, 5026, 5040, 5055, 5070, 5075, 5078, 5084, 5086, 5097, 5106, 5114, 5119, 5129, 5138, 5148, 5155, 5174, 5176, 5187, 5197, 5200, 5207, 5212, 5217, 5227, 5231, 5234, 5238, 5242, 5245, 5249, 5255, 5259, 5265, 5278, 5286, 5289, 5293, 5309, 5314, 5318, 5323, 5328, 5333, 5340, 5357, 5364, 5368, 5373, 5378, 5380, 5384, 5391, 5394, 5399, 5403, 5409, 5415, 5418, 5421, 5425, 5428, 5432, 5435, 5439, 5445, 5450, 5454, 5459, 5463, 5472, 5477, 5479, 5508, 5518, 5527, 5535, 5547, 5569, 5573, 5581, 5587, 5592, 5598, 5610, 5630, 5640, 5643, 5650, 5654, 5659, 5665, 5671, 5682, 5684, 5692, 5700, 5710, 5731, 5744, 5750, 5756, 5763, 5765, 5776, 5786, 5805, 5818, 5823, 5831, 5840, 5844, 5858, 5865, 5869, 5871, 5880, 5883, 5888, 5890, 5898, 5901, 5906, 5919, 5931, 5934, 5937, 5943, 5955, 5960, 5964, 5968, 5972, 5974, 5979, 5986, 5991, 5993, 6004, 6009, 6013, 6033, 6043, 6055, 6061, 6065, 6070, 6076, 6086, 6092, 6096, 6107, 6119, 6127, 6129, 6139, 6144, 6176, 6182, 6188, 6193, 6201, 6206, 6212, 6216, 6219, 6222, 6226, 6232, 6244, 6247, 6250, 6253, 6264, 6273, 6275, 6282, 6287, 6292, 6297, 6301, 6304, 6315, 6317, 6324, 6326, 6335, 6341, 6348, 6353, 6358, 6362, 6372, 6380, 6383, 6388, 6390, 6393, 6399, 6404, 6411, 6421, 6426, 6430, 6433, 6445, 6450, 6455, 6461, 6468, 6471, 6482, 6487, 6489, 6492, 6495, 6503, 6506, 6510, 6513, 6517, 6530, 6533, 6537, 6541, 6544, 6551, 6558, 6562, 6565, 6574, 6577, 6588, 6590, 6598, 6600, 6611, 6613, 6620, 6622, 6626, 6630, 6633, 6643, 6649, 6651, 6654, 6660, 6665, 6670, 6679, 6685, 6687, 6690, 6698, 6704, 6708, 6714, 6717, 6726, 6731, 6733, 6735, 6738, 6747, 6752, 6763, 6777, 6787, 6793, 6801, 6807, 6812, 6816, 6830, 6835, 6838, 6841, 6847, 6853, 6860, 6865, 6868, 6873, 6878, 6881, 6885, 6893, 6900, 6904, 6909, 6921, 6926, 6928, 6931, 6936, 6940, 6943, 6946, 6954, 6957, 6964, 6966, 6970, 6973, 6977, 6981, 6984, 6987, 6995, 7004, 7007, 7014, 7016, 7020, 7026, 7034, 7040, 7045, 7050, 7054, 7059, 7061, 7067, 7071, 7078, 7083, 7086, 7093, 7100, 7102, 7110, 7112, 7118, 7121, 7124, 7129, 7133, 7143, 7149, 7157, 7161, 7165, 7169, 7175, 7178, 7181, 7188, 7192, 7202, 7214, 7224, 7231, 7243, 7250, 7258, 7262, 7266, 7274, 7289, 7294, 7296, 7305, 7308, 7312, 7315, 7319, 7332, 7335, 7339, 7342, 7347, 7354, 7359, 7367, 7372, 7375, 7388, 7393, 7397, 7400, 7405, 7408, 7413, 7418, 7425, 7428, 7431, 7435, 7442, 7445, 7448, 7452, 7456, 7460, 7465, 7471, 7473, 7488, 7495, 7503, 7506, 7509, 7516, 7520, 7524, 7526, 7534, 7541, 7558, 7563, 7569, 7575, 7583, 7597, 7602, 7609, 7617, 7625, 7629, 7638] diff --git a/sql_to_code/parsers/generated/PLpgSQLParser.py b/sql_to_code/parsers/generated/PLpgSQLParser.py new file mode 100644 index 0000000..89d955c --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLParser.py @@ -0,0 +1,53242 @@ +# Generated from PLpgSQLParser.g4 by ANTLR 4.9 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0270") + buf.write("\u1dd9\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") + buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") + buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") + buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") + buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36") + buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t") + buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4") + buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64") + buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t") + buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t") + buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t") + buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t") + buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4") + buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4") + buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4") + buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4") + buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080") + buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084") + buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087") + buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b") + buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e") + buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092") + buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095") + buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099") + buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c") + buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0") + buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3") + buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7") + buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa") + buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae") + buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1") + buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5") + buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8") + buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc") + buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf") + buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3") + buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6") + buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca") + buf.write("\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd\t\u00cd") + buf.write("\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1") + buf.write("\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4") + buf.write("\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8") + buf.write("\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db") + buf.write("\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df") + buf.write("\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2") + buf.write("\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6") + buf.write("\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9") + buf.write("\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec\4\u00ed") + buf.write("\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0") + buf.write("\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4") + buf.write("\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7\t\u00f7") + buf.write("\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb") + buf.write("\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe") + buf.write("\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101\4\u0102") + buf.write("\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104\4\u0105\t\u0105") + buf.write("\4\u0106\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109") + buf.write("\t\u0109\4\u010a\t\u010a\4\u010b\t\u010b\4\u010c\t\u010c") + buf.write("\4\u010d\t\u010d\4\u010e\t\u010e\4\u010f\t\u010f\4\u0110") + buf.write("\t\u0110\4\u0111\t\u0111\4\u0112\t\u0112\4\u0113\t\u0113") + buf.write("\4\u0114\t\u0114\4\u0115\t\u0115\4\u0116\t\u0116\4\u0117") + buf.write("\t\u0117\4\u0118\t\u0118\4\u0119\t\u0119\4\u011a\t\u011a") + buf.write("\4\u011b\t\u011b\4\u011c\t\u011c\4\u011d\t\u011d\4\u011e") + buf.write("\t\u011e\4\u011f\t\u011f\4\u0120\t\u0120\4\u0121\t\u0121") + buf.write("\4\u0122\t\u0122\4\u0123\t\u0123\4\u0124\t\u0124\4\u0125") + buf.write("\t\u0125\4\u0126\t\u0126\4\u0127\t\u0127\4\u0128\t\u0128") + buf.write("\4\u0129\t\u0129\4\u012a\t\u012a\4\u012b\t\u012b\4\u012c") + buf.write("\t\u012c\4\u012d\t\u012d\4\u012e\t\u012e\4\u012f\t\u012f") + buf.write("\4\u0130\t\u0130\4\u0131\t\u0131\4\u0132\t\u0132\4\u0133") + buf.write("\t\u0133\4\u0134\t\u0134\4\u0135\t\u0135\4\u0136\t\u0136") + buf.write("\4\u0137\t\u0137\4\u0138\t\u0138\4\u0139\t\u0139\4\u013a") + buf.write("\t\u013a\4\u013b\t\u013b\4\u013c\t\u013c\4\u013d\t\u013d") + buf.write("\4\u013e\t\u013e\4\u013f\t\u013f\4\u0140\t\u0140\4\u0141") + buf.write("\t\u0141\4\u0142\t\u0142\4\u0143\t\u0143\4\u0144\t\u0144") + buf.write("\4\u0145\t\u0145\4\u0146\t\u0146\4\u0147\t\u0147\4\u0148") + buf.write("\t\u0148\4\u0149\t\u0149\4\u014a\t\u014a\4\u014b\t\u014b") + buf.write("\4\u014c\t\u014c\4\u014d\t\u014d\4\u014e\t\u014e\4\u014f") + buf.write("\t\u014f\4\u0150\t\u0150\4\u0151\t\u0151\4\u0152\t\u0152") + buf.write("\4\u0153\t\u0153\4\u0154\t\u0154\4\u0155\t\u0155\4\u0156") + buf.write("\t\u0156\4\u0157\t\u0157\4\u0158\t\u0158\4\u0159\t\u0159") + buf.write("\4\u015a\t\u015a\4\u015b\t\u015b\4\u015c\t\u015c\4\u015d") + buf.write("\t\u015d\4\u015e\t\u015e\4\u015f\t\u015f\4\u0160\t\u0160") + buf.write("\4\u0161\t\u0161\4\u0162\t\u0162\4\u0163\t\u0163\4\u0164") + buf.write("\t\u0164\4\u0165\t\u0165\4\u0166\t\u0166\4\u0167\t\u0167") + buf.write("\4\u0168\t\u0168\4\u0169\t\u0169\4\u016a\t\u016a\4\u016b") + buf.write("\t\u016b\4\u016c\t\u016c\4\u016d\t\u016d\4\u016e\t\u016e") + buf.write("\4\u016f\t\u016f\4\u0170\t\u0170\4\u0171\t\u0171\4\u0172") + buf.write("\t\u0172\4\u0173\t\u0173\4\u0174\t\u0174\4\u0175\t\u0175") + buf.write("\4\u0176\t\u0176\4\u0177\t\u0177\4\u0178\t\u0178\4\u0179") + buf.write("\t\u0179\4\u017a\t\u017a\4\u017b\t\u017b\4\u017c\t\u017c") + buf.write("\4\u017d\t\u017d\3\2\5\2\u02fc\n\2\3\2\7\2\u02ff\n\2\f") + buf.write("\2\16\2\u0302\13\2\3\2\3\2\6\2\u0306\n\2\r\2\16\2\u0307") + buf.write("\3\2\5\2\u030b\n\2\7\2\u030d\n\2\f\2\16\2\u0310\13\2\3") + buf.write("\2\3\2\3\3\3\3\3\3\3\4\5\4\u0318\n\4\3\4\3\4\3\4\3\5\3") + buf.write("\5\3\5\7\5\u0320\n\5\f\5\16\5\u0323\13\5\3\5\3\5\3\6\5") + buf.write("\6\u0328\n\6\3\6\3\6\5\6\u032c\n\6\3\6\3\6\3\7\5\7\u0331") + buf.write("\n\7\3\7\3\7\3\7\7\7\u0336\n\7\f\7\16\7\u0339\13\7\3\7") + buf.write("\3\7\3\b\3\b\3\b\5\b\u0340\n\b\3\t\3\t\3\t\3\t\5\t\u0346") + buf.write("\n\t\3\n\3\n\5\n\u034a\n\n\3\13\3\13\3\13\3\13\5\13\u0350") + buf.write("\n\13\5\13\u0352\n\13\3\13\3\13\3\13\7\13\u0357\n\13\f") + buf.write("\13\16\13\u035a\13\13\5\13\u035c\n\13\3\13\3\13\5\13\u0360") + buf.write("\n\13\3\13\3\13\5\13\u0364\n\13\3\13\5\13\u0367\n\13\3") + buf.write("\13\3\13\3\13\3\13\5\13\u036d\n\13\3\13\3\13\3\13\3\13") + buf.write("\5\13\u0373\n\13\5\13\u0375\n\13\3\13\3\13\3\13\3\13\3") + buf.write("\13\3\13\5\13\u037d\n\13\3\13\3\13\5\13\u0381\n\13\3\13") + buf.write("\3\13\5\13\u0385\n\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f") + buf.write("\3\f\5\f\u0390\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u0397\n\f\3") + buf.write("\f\5\f\u039a\n\f\3\r\3\r\5\r\u039e\n\r\3\r\3\r\3\r\7\r") + buf.write("\u03a3\n\r\f\r\16\r\u03a6\13\r\3\r\3\r\3\r\3\r\5\r\u03ac") + buf.write("\n\r\3\r\5\r\u03af\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3") + buf.write("\16\3\16\3\16\5\16\u03ba\n\16\3\16\5\16\u03bd\n\16\3\17") + buf.write("\3\17\3\17\3\17\5\17\u03c3\n\17\3\17\3\17\5\17\u03c7\n") + buf.write("\17\3\17\5\17\u03ca\n\17\3\17\3\17\3\17\3\17\5\17\u03d0") + buf.write("\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u03da") + buf.write("\n\17\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u03e2\n\20\3") + buf.write("\20\3\20\3\20\3\20\3\20\7\20\u03e9\n\20\f\20\16\20\u03ec") + buf.write("\13\20\3\20\3\20\3\20\5\20\u03f1\n\20\3\20\5\20\u03f4") + buf.write("\n\20\3\20\3\20\5\20\u03f8\n\20\3\20\3\20\3\20\3\20\3") + buf.write("\20\3\20\3\20\5\20\u0401\n\20\5\20\u0403\n\20\3\20\3\20") + buf.write("\3\20\3\20\3\20\5\20\u040a\n\20\3\20\3\20\5\20\u040e\n") + buf.write("\20\3\20\3\20\3\20\3\20\5\20\u0414\n\20\3\20\3\20\5\20") + buf.write("\u0418\n\20\3\20\3\20\3\20\3\20\3\20\5\20\u041f\n\20\3") + buf.write("\20\3\20\3\20\3\20\3\20\3\20\5\20\u0427\n\20\3\20\3\20") + buf.write("\3\20\3\20\5\20\u042d\n\20\3\20\3\20\3\20\5\20\u0432\n") + buf.write("\20\3\20\5\20\u0435\n\20\3\20\3\20\3\20\3\20\3\20\3\20") + buf.write("\7\20\u043d\n\20\f\20\16\20\u0440\13\20\3\20\3\20\5\20") + buf.write("\u0444\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3") + buf.write("\20\7\20\u044f\n\20\f\20\16\20\u0452\13\20\3\20\3\20\3") + buf.write("\20\3\20\3\20\3\20\5\20\u045a\n\20\3\21\3\21\5\21\u045e") + buf.write("\n\21\3\21\5\21\u0461\n\21\3\21\3\21\3\21\3\21\7\21\u0467") + buf.write("\n\21\f\21\16\21\u046a\13\21\3\21\3\21\5\21\u046e\n\21") + buf.write("\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u0478\n") + buf.write("\22\5\22\u047a\n\22\3\23\3\23\3\23\3\23\3\23\3\23\7\23") + buf.write("\u0482\n\23\f\23\16\23\u0485\13\23\3\23\3\23\5\23\u0489") + buf.write("\n\23\3\24\3\24\3\24\5\24\u048e\n\24\3\24\5\24\u0491\n") + buf.write("\24\3\24\5\24\u0494\n\24\3\24\5\24\u0497\n\24\3\24\3\24") + buf.write("\3\24\5\24\u049c\n\24\3\24\3\24\3\24\3\25\3\25\3\25\3") + buf.write("\25\5\25\u04a5\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25") + buf.write("\3\25\3\25\5\25\u04b0\n\25\3\26\3\26\5\26\u04b4\n\26\3") + buf.write("\26\3\26\5\26\u04b8\n\26\3\27\3\27\3\27\5\27\u04bd\n\27") + buf.write("\3\30\3\30\3\30\7\30\u04c2\n\30\f\30\16\30\u04c5\13\30") + buf.write("\3\31\3\31\3\31\3\31\3\31\7\31\u04cc\n\31\f\31\16\31\u04cf") + buf.write("\13\31\3\31\3\31\5\31\u04d3\n\31\3\32\3\32\3\32\3\32\7") + buf.write("\32\u04d9\n\32\f\32\16\32\u04dc\13\32\3\32\3\32\3\32\5") + buf.write("\32\u04e1\n\32\3\32\5\32\u04e4\n\32\3\32\5\32\u04e7\n") + buf.write("\32\3\32\5\32\u04ea\n\32\5\32\u04ec\n\32\3\33\3\33\5\33") + buf.write("\u04f0\n\33\3\34\3\34\5\34\u04f4\n\34\3\35\3\35\3\36\3") + buf.write("\36\3\36\3\36\3\36\5\36\u04fd\n\36\3\36\3\36\3\36\3\36") + buf.write("\5\36\u0503\n\36\3\36\3\36\5\36\u0507\n\36\5\36\u0509") + buf.write("\n\36\3\37\3\37\3\37\5\37\u050e\n\37\3 \3 \3 \3 \3 \3") + buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3") + buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u0537") + buf.write("\n \3 \3 \3 \3 \3 \5 \u053e\n \3!\3!\3!\3!\3!\3!\3!\3") + buf.write("!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3") + buf.write("!\3!\3!\3!\3!\3!\3!\3!\5!\u0561\n!\3\"\3\"\3\"\3\"\3\"") + buf.write("\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u056f\n\"\3#\3#\3#\3") + buf.write("#\3#\3#\3#\5#\u0578\n#\3#\3#\3#\3#\5#\u057e\n#\3#\3#\3") + buf.write("#\3#\3#\3#\5#\u0586\n#\3$\3$\5$\u058a\n$\3$\3$\3$\3$\3") + buf.write("$\5$\u0591\n$\3$\3$\5$\u0595\n$\6$\u0597\n$\r$\16$\u0598") + buf.write("\3$\5$\u059c\n$\3$\3$\3$\3$\3$\3$\5$\u05a4\n$\3%\3%\3") + buf.write("%\3%\5%\u05aa\n%\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\5\'\u05b5") + buf.write("\n\'\5\'\u05b7\n\'\3\'\3\'\5\'\u05bb\n\'\3(\3(\3(\3(\3") + buf.write("(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3") + buf.write("(\3(\3(\3(\3(\3(\3(\3(\3(\5(\u05dc\n(\3(\3(\3(\3(\3(\3") + buf.write("(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\5(\u05ef\n(\3(\3(\3") + buf.write("(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3") + buf.write("(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\5") + buf.write("(\u0617\n(\3)\3)\3)\3)\3*\5*\u061e\n*\3*\3*\3*\3*\5*\u0624") + buf.write("\n*\3+\5+\u0627\n+\3+\3+\5+\u062b\n+\3+\5+\u062e\n+\3") + buf.write("+\3+\5+\u0632\n+\3+\3+\3+\7+\u0637\n+\f+\16+\u063a\13") + buf.write("+\3+\3+\5+\u063e\n+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3") + buf.write("+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u0654\n+\3,\3,\5,\u0658\n") + buf.write(",\3,\5,\u065b\n,\3,\3,\3,\5,\u0660\n,\3,\5,\u0663\n,\3") + buf.write(",\3,\5,\u0667\n,\3,\3,\5,\u066b\n,\3,\3,\3,\3,\3,\3,\3") + buf.write(",\5,\u0674\n,\3,\3,\3,\3,\3,\3,\3,\5,\u067d\n,\3,\3,\3") + buf.write(",\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\5,\u068f\n,\3") + buf.write(",\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3") + buf.write(",\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3") + buf.write(",\3,\3,\3,\5,\u06b9\n,\3,\3,\3,\3,\5,\u06bf\n,\3,\5,\u06c2") + buf.write("\n,\5,\u06c4\n,\3-\3-\5-\u06c8\n-\3-\3-\3-\5-\u06cd\n") + buf.write("-\3-\3-\5-\u06d1\n-\3-\3-\3-\3-\3-\3-\5-\u06d9\n-\3-\3") + buf.write("-\3-\3-\3-\5-\u06e0\n-\3-\3-\3-\3-\3-\3-\3-\3-\3-\3-\3") + buf.write("-\3-\6-\u06ee\n-\r-\16-\u06ef\5-\u06f2\n-\3.\3.\3.\3.") + buf.write("\5.\u06f8\n.\3.\3.\3.\3.\6.\u06fe\n.\r.\16.\u06ff\3.\3") + buf.write(".\5.\u0704\n.\3/\3/\3/\3/\3/\5/\u070b\n/\3/\3/\3/\3/\5") + buf.write("/\u0711\n/\3/\5/\u0714\n/\5/\u0716\n/\3\60\3\60\3\61\3") + buf.write("\61\3\61\3\61\3\62\3\62\3\62\5\62\u0721\n\62\3\62\3\62") + buf.write("\5\62\u0725\n\62\3\63\5\63\u0728\n\63\3\63\3\63\3\64\3") + buf.write("\64\3\64\3\65\3\65\3\65\5\65\u0732\n\65\3\65\3\65\3\65") + buf.write("\3\65\3\65\3\65\3\65\7\65\u073b\n\65\f\65\16\65\u073e") + buf.write("\13\65\3\65\3\65\3\65\3\65\3\65\5\65\u0745\n\65\3\65\3") + buf.write("\65\5\65\u0749\n\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65") + buf.write("\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u0759\n\65\3") + buf.write("\65\3\65\3\65\3\65\3\65\5\65\u0760\n\65\3\65\3\65\3\65") + buf.write("\3\65\3\65\5\65\u0767\n\65\3\66\3\66\3\66\5\66\u076c\n") + buf.write("\66\3\67\3\67\5\67\u0770\n\67\3\67\3\67\3\67\3\67\3\67") + buf.write("\3\67\3\67\3\67\3\67\3\67\3\67\5\67\u077d\n\67\3\67\3") + buf.write("\67\3\67\3\67\5\67\u0783\n\67\5\67\u0785\n\67\38\38\3") + buf.write("8\38\38\38\38\38\38\38\58\u0791\n8\38\58\u0794\n8\38\3") + buf.write("8\38\38\38\38\38\38\38\38\38\38\38\38\38\38\38\78\u07a7") + buf.write("\n8\f8\168\u07aa\138\38\38\58\u07ae\n8\39\39\39\39\39") + buf.write("\59\u07b5\n9\39\39\39\59\u07ba\n9\39\39\3:\3:\3:\5:\u07c1") + buf.write("\n:\5:\u07c3\n:\3:\3:\3:\7:\u07c8\n:\f:\16:\u07cb\13:") + buf.write("\3:\3:\3:\3:\3:\3:\7:\u07d3\n:\f:\16:\u07d6\13:\3:\3:") + buf.write("\5:\u07da\n:\5:\u07dc\n:\3:\3:\3:\3:\3:\5:\u07e3\n:\5") + buf.write(":\u07e5\n:\3:\3:\3:\3:\3:\3:\5:\u07ed\n:\5:\u07ef\n:\3") + buf.write(":\3:\3:\3:\3:\5:\u07f6\n:\5:\u07f8\n:\3:\3:\5:\u07fc\n") + buf.write(":\3:\3:\5:\u0800\n:\3;\3;\3;\3;\3<\3<\5<\u0808\n<\3<\3") + buf.write("<\3<\3<\5<\u080e\n<\3<\5<\u0811\n<\7<\u0813\n<\f<\16<") + buf.write("\u0816\13<\3<\3<\5<\u081a\n<\3=\5=\u081d\n=\3=\3=\5=\u0821") + buf.write("\n=\3=\3=\3=\5=\u0826\n=\3=\3=\3=\5=\u082b\n=\3=\3=\3") + buf.write("=\3=\3=\3=\5=\u0833\n=\3>\3>\3>\3>\3>\3?\3?\3?\5?\u083d") + buf.write("\n?\3?\3?\5?\u0841\n?\3@\3@\3@\3@\3@\3@\3@\5@\u084a\n") + buf.write("@\3@\3@\3@\5@\u084f\n@\3@\3@\3@\3@\3@\3@\5@\u0857\n@\3") + buf.write("@\3@\3@\3@\3@\3@\3@\3@\3@\7@\u0862\n@\f@\16@\u0865\13") + buf.write("@\5@\u0867\n@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u0874") + buf.write("\nA\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u0880\nA\3B\3B\3") + buf.write("B\3B\3C\3C\5C\u0888\nC\3C\3C\3C\3C\3C\5C\u088f\nC\3D\3") + buf.write("D\3D\3D\3D\3D\5D\u0897\nD\3D\3D\3D\3D\3D\3D\3D\3D\5D\u08a1") + buf.write("\nD\3E\3E\3E\3E\3E\3E\3E\3E\7E\u08ab\nE\fE\16E\u08ae\13") + buf.write("E\3E\3E\3E\3E\5E\u08b4\nE\3E\3E\3E\3E\3E\3E\3E\3E\3E\5") + buf.write("E\u08bf\nE\3E\3E\5E\u08c3\nE\3F\3F\3F\3F\3F\5F\u08ca\n") + buf.write("F\3F\5F\u08cd\nF\3F\3F\3F\5F\u08d2\nF\3F\3F\5F\u08d6\n") + buf.write("F\3F\3F\3F\3F\3F\5F\u08dd\nF\3F\3F\3F\5F\u08e2\nF\3F\5") + buf.write("F\u08e5\nF\5F\u08e7\nF\3G\3G\3G\3G\3H\3H\3H\3I\5I\u08f1") + buf.write("\nI\3I\3I\5I\u08f5\nI\3I\5I\u08f8\nI\3I\5I\u08fb\nI\3") + buf.write("I\3I\5I\u08ff\nI\3I\3I\3I\3J\3J\5J\u0906\nJ\3J\3J\5J\u090a") + buf.write("\nJ\3J\5J\u090d\nJ\3J\5J\u0910\nJ\3J\5J\u0913\nJ\3K\3") + buf.write("K\3K\3K\3L\3L\3L\3L\3L\7L\u091e\nL\fL\16L\u0921\13L\3") + buf.write("L\3L\3M\3M\3M\3N\3N\5N\u092a\nN\3N\3N\5N\u092e\nN\3N\3") + buf.write("N\5N\u0932\nN\3N\3N\3N\5N\u0937\nN\5N\u0939\nN\3N\3N\3") + buf.write("N\5N\u093e\nN\5N\u0940\nN\3N\5N\u0943\nN\3O\3O\5O\u0947") + buf.write("\nO\3O\5O\u094a\nO\3O\5O\u094d\nO\3O\3O\3O\3O\3O\3O\5") + buf.write("O\u0955\nO\3O\3O\5O\u0959\nO\5O\u095b\nO\3P\3P\3P\3P\3") + buf.write("P\3P\3P\3P\3P\3P\3P\3P\7P\u0969\nP\fP\16P\u096c\13P\3") + buf.write("P\3P\5P\u0970\nP\6P\u0972\nP\rP\16P\u0973\5P\u0976\nP") + buf.write("\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u0983\nQ\fQ\16Q\u0986") + buf.write("\13Q\5Q\u0988\nQ\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u0990\nQ\fQ\16Q") + buf.write("\u0993\13Q\5Q\u0995\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3") + buf.write("Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u09a9\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3") + buf.write("Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u09bb\nQ\7Q\u09bd\nQ\f") + buf.write("Q\16Q\u09c0\13Q\3Q\5Q\u09c3\nQ\3Q\3Q\3Q\3Q\3Q\5Q\u09ca") + buf.write("\nQ\3Q\5Q\u09cd\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3") + buf.write("Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u09ea") + buf.write("\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3") + buf.write("Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u0a08\nQ\7Q\u0a0a") + buf.write("\nQ\fQ\16Q\u0a0d\13Q\3Q\3Q\5Q\u0a11\nQ\3R\3R\3R\5R\u0a16") + buf.write("\nR\3R\3R\3R\3R\3R\7R\u0a1d\nR\fR\16R\u0a20\13R\3S\3S") + buf.write("\5S\u0a24\nS\3S\3S\3S\5S\u0a29\nS\3S\3S\5S\u0a2d\nS\3") + buf.write("S\3S\3S\3S\3S\5S\u0a34\nS\3T\3T\3T\3T\3T\3T\3T\3T\3T\3") + buf.write("T\7T\u0a40\nT\fT\16T\u0a43\13T\3T\3T\3U\3U\3U\3U\3V\3") + buf.write("V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u0a56\nV\3V\3V\3W\3W\3") + buf.write("W\3W\3W\3W\3W\3W\3W\3W\5W\u0a64\nW\3W\3W\3W\3W\3W\3W\3") + buf.write("W\5W\u0a6d\nW\3W\3W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3") + buf.write("X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u0a87\nX\3X\3X\3X\3") + buf.write("X\3X\3X\3X\5X\u0a90\nX\3X\3X\3Y\3Y\5Y\u0a96\nY\3Y\3Y\3") + buf.write("Y\3Y\3Y\3Y\3Y\7Y\u0a9f\nY\fY\16Y\u0aa2\13Y\5Y\u0aa4\n") + buf.write("Y\3Y\5Y\u0aa7\nY\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u0ab0\nZ\3[\3") + buf.write("[\3[\3[\5[\u0ab6\n[\3[\3[\3[\5[\u0abb\n[\3\\\3\\\3\\\5") + buf.write("\\\u0ac0\n\\\3\\\3\\\3\\\5\\\u0ac5\n\\\3\\\3\\\3\\\5\\") + buf.write("\u0aca\n\\\3]\3]\3]\3]\3]\5]\u0ad1\n]\3]\3]\3]\5]\u0ad6") + buf.write("\n]\3^\3^\3^\3^\3^\3^\3^\5^\u0adf\n^\3^\6^\u0ae2\n^\r") + buf.write("^\16^\u0ae3\5^\u0ae6\n^\3_\3_\5_\u0aea\n_\3_\3_\3_\5_") + buf.write("\u0aef\n_\3_\3_\3`\3`\3`\3`\5`\u0af7\n`\3`\3`\3`\3`\3") + buf.write("`\3`\3`\3`\5`\u0b01\n`\3`\3`\3`\3`\3`\3`\3`\3`\5`\u0b0b") + buf.write("\n`\3`\3`\3`\5`\u0b10\n`\3a\3a\3a\3b\3b\3b\3b\3b\3b\3") + buf.write("b\3b\5b\u0b1d\nb\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3") + buf.write("d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\5d\u0b37\nd\3d\5d\u0b3a") + buf.write("\nd\3d\5d\u0b3d\nd\3d\5d\u0b40\nd\3d\3d\3e\3e\3e\3e\3") + buf.write("e\3e\3e\7e\u0b4b\ne\fe\16e\u0b4e\13e\3e\3e\3e\3e\3e\3") + buf.write("e\3e\5e\u0b57\ne\3f\3f\3f\3f\3f\5f\u0b5e\nf\3g\3g\3g\3") + buf.write("g\3g\3g\3h\3h\3h\3h\5h\u0b6a\nh\3h\3h\3h\3h\5h\u0b70\n") + buf.write("h\3h\5h\u0b73\nh\3h\3h\5h\u0b77\nh\3i\3i\3i\3i\3j\3j\3") + buf.write("j\3j\3j\3j\7j\u0b83\nj\fj\16j\u0b86\13j\3j\3j\5j\u0b8a") + buf.write("\nj\3k\3k\3k\3k\3l\3l\3l\5l\u0b93\nl\3l\3l\3l\5l\u0b98") + buf.write("\nl\3l\3l\3l\3m\3m\3m\3m\3m\7m\u0ba2\nm\fm\16m\u0ba5\13") + buf.write("m\3m\5m\u0ba8\nm\3n\3n\5n\u0bac\nn\3n\3n\3n\7n\u0bb1\n") + buf.write("n\fn\16n\u0bb4\13n\3n\5n\u0bb7\nn\3o\3o\3o\3o\5o\u0bbd") + buf.write("\no\3o\3o\3o\5o\u0bc2\no\3o\3o\3p\3p\5p\u0bc8\np\3p\3") + buf.write("p\3p\3p\3p\3p\5p\u0bd0\np\3p\5p\u0bd3\np\3q\3q\5q\u0bd7") + buf.write("\nq\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3") + buf.write("q\3q\3q\3r\3r\3r\3r\3r\3r\3r\3r\3s\3s\3s\5s\u0bf7\ns\3") + buf.write("s\3s\7s\u0bfb\ns\fs\16s\u0bfe\13s\5s\u0c00\ns\3t\3t\3") + buf.write("t\5t\u0c05\nt\3u\3u\5u\u0c09\nu\3v\3v\3v\3v\3v\3v\3v\3") + buf.write("v\3v\3v\3v\5v\u0c16\nv\3v\3v\3v\5v\u0c1b\nv\3v\3v\3v\5") + buf.write("v\u0c20\nv\3w\3w\3w\3w\3w\3w\3w\5w\u0c29\nw\3x\3x\3x\3") + buf.write("x\3x\3x\3x\3x\3x\5x\u0c34\nx\3x\5x\u0c37\nx\3y\3y\3y\5") + buf.write("y\u0c3c\ny\3y\6y\u0c3f\ny\ry\16y\u0c40\5y\u0c43\ny\3z") + buf.write("\3z\5z\u0c47\nz\3{\3{\3{\3{\5{\u0c4d\n{\3{\3{\3{\3{\3") + buf.write("{\3{\3{\7{\u0c56\n{\f{\16{\u0c59\13{\3{\3{\5{\u0c5d\n") + buf.write("{\3|\3|\5|\u0c61\n|\3|\3|\3|\3|\3|\5|\u0c68\n|\3|\3|\3") + buf.write("|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\5}\u0c79\n}\3}\3") + buf.write("}\3}\3}\5}\u0c7f\n}\3}\3}\3}\3}\3}\7}\u0c86\n}\f}\16}") + buf.write("\u0c89\13}\3}\3}\5}\u0c8d\n}\3~\3~\3~\3\177\3\177\3\177") + buf.write("\3\177\3\177\3\177\7\177\u0c98\n\177\f\177\16\177\u0c9b") + buf.write("\13\177\3\177\3\177\3\u0080\3\u0080\3\u0080\5\u0080\u0ca2") + buf.write("\n\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081") + buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081") + buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\5\u0081") + buf.write("\u0cb7\n\u0081\3\u0082\3\u0082\5\u0082\u0cbb\n\u0082\3") + buf.write("\u0082\3\u0082\3\u0082\5\u0082\u0cc0\n\u0082\3\u0082\3") + buf.write("\u0082\3\u0082\3\u0082\3\u0082\3\u0082\5\u0082\u0cc8\n") + buf.write("\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082") + buf.write("\3\u0082\3\u0082\3\u0082\7\u0082\u0cd3\n\u0082\f\u0082") + buf.write("\16\u0082\u0cd6\13\u0082\3\u0082\3\u0082\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083") + buf.write("\5\u0083\u0d0d\n\u0083\3\u0084\3\u0084\3\u0084\3\u0085") + buf.write("\3\u0085\3\u0085\5\u0085\u0d15\n\u0085\3\u0085\3\u0085") + buf.write("\3\u0085\3\u0085\3\u0085\7\u0085\u0d1c\n\u0085\f\u0085") + buf.write("\16\u0085\u0d1f\13\u0085\3\u0085\3\u0085\3\u0085\3\u0085") + buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\7\u0085") + buf.write("\u0d2b\n\u0085\f\u0085\16\u0085\u0d2e\13\u0085\3\u0085") + buf.write("\5\u0085\u0d31\n\u0085\3\u0085\3\u0085\3\u0085\3\u0085") + buf.write("\5\u0085\u0d37\n\u0085\3\u0086\3\u0086\3\u0086\3\u0086") + buf.write("\3\u0086\5\u0086\u0d3e\n\u0086\3\u0086\3\u0086\3\u0086") + buf.write("\3\u0086\3\u0086\3\u0086\5\u0086\u0d46\n\u0086\3\u0086") + buf.write("\3\u0086\3\u0086\5\u0086\u0d4b\n\u0086\3\u0086\3\u0086") + buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u0d54") + buf.write("\n\u0086\5\u0086\u0d56\n\u0086\3\u0087\3\u0087\3\u0087") + buf.write("\7\u0087\u0d5b\n\u0087\f\u0087\16\u0087\u0d5e\13\u0087") + buf.write("\3\u0087\5\u0087\u0d61\n\u0087\3\u0088\3\u0088\5\u0088") + buf.write("\u0d65\n\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088") + buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\5\u0088\u0d70\n\u0088") + buf.write("\3\u0088\3\u0088\5\u0088\u0d74\n\u0088\3\u0088\3\u0088") + buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\7\u0088\u0d7c\n\u0088") + buf.write("\f\u0088\16\u0088\u0d7f\13\u0088\3\u0088\3\u0088\5\u0088") + buf.write("\u0d83\n\u0088\3\u0088\3\u0088\5\u0088\u0d87\n\u0088\3") + buf.write("\u0089\3\u0089\3\u0089\3\u0089\3\u0089\5\u0089\u0d8e\n") + buf.write("\u0089\3\u008a\5\u008a\u0d91\n\u008a\3\u008a\3\u008a\3") + buf.write("\u008a\3\u008a\3\u008a\3\u008a\5\u008a\u0d99\n\u008a\3") + buf.write("\u008a\3\u008a\3\u008a\5\u008a\u0d9e\n\u008a\3\u008a\3") + buf.write("\u008a\3\u008a\5\u008a\u0da3\n\u008a\5\u008a\u0da5\n\u008a") + buf.write("\3\u008a\5\u008a\u0da8\n\u008a\6\u008a\u0daa\n\u008a\r") + buf.write("\u008a\16\u008a\u0dab\3\u008a\3\u008a\3\u008a\3\u008a") + buf.write("\5\u008a\u0db2\n\u008a\3\u008a\5\u008a\u0db5\n\u008a\3") + buf.write("\u008a\5\u008a\u0db8\n\u008a\3\u008a\3\u008a\3\u008a\5") + buf.write("\u008a\u0dbd\n\u008a\5\u008a\u0dbf\n\u008a\3\u008a\3\u008a") + buf.write("\5\u008a\u0dc3\n\u008a\3\u008a\5\u008a\u0dc6\n\u008a\3") + buf.write("\u008a\5\u008a\u0dc9\n\u008a\3\u008a\3\u008a\3\u008a\3") + buf.write("\u008a\3\u008b\3\u008b\3\u008b\5\u008b\u0dd2\n\u008b\3") + buf.write("\u008b\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c") + buf.write("\3\u008d\3\u008d\3\u008d\5\u008d\u0dde\n\u008d\5\u008d") + buf.write("\u0de0\n\u008d\3\u008d\3\u008d\5\u008d\u0de4\n\u008d\3") + buf.write("\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d\3\u008d") + buf.write("\3\u008d\5\u008d\u0dee\n\u008d\3\u008d\5\u008d\u0df1\n") + buf.write("\u008d\3\u008e\5\u008e\u0df4\n\u008e\3\u008e\3\u008e\3") + buf.write("\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\7\u008e\u0e08\n\u008e\f\u008e\16\u008e") + buf.write("\u0e0b\13\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e") + buf.write("\7\u008e\u0e12\n\u008e\f\u008e\16\u008e\u0e15\13\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e") + buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e") + buf.write("\u0e24\n\u008e\3\u008f\3\u008f\3\u008f\7\u008f\u0e29\n") + buf.write("\u008f\f\u008f\16\u008f\u0e2c\13\u008f\3\u0090\3\u0090") + buf.write("\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\7\u0091") + buf.write("\u0e36\n\u0091\f\u0091\16\u0091\u0e39\13\u0091\3\u0092") + buf.write("\3\u0092\5\u0092\u0e3d\n\u0092\3\u0092\3\u0092\3\u0092") + buf.write("\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092") + buf.write("\3\u0092\3\u0092\5\u0092\u0e4b\n\u0092\3\u0093\3\u0093") + buf.write("\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u0e54") + buf.write("\n\u0093\3\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u0e5a") + buf.write("\n\u0093\3\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u0e60") + buf.write("\n\u0093\5\u0093\u0e62\n\u0093\3\u0094\3\u0094\3\u0094") + buf.write("\3\u0094\3\u0094\5\u0094\u0e69\n\u0094\3\u0095\3\u0095") + buf.write("\3\u0095\5\u0095\u0e6e\n\u0095\3\u0096\3\u0096\3\u0096") + buf.write("\7\u0096\u0e73\n\u0096\f\u0096\16\u0096\u0e76\13\u0096") + buf.write("\3\u0097\5\u0097\u0e79\n\u0097\3\u0097\3\u0097\3\u0098") + buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\5\u0098\u0e83") + buf.write("\n\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099") + buf.write("\u0e8a\n\u0099\5\u0099\u0e8c\n\u0099\3\u0099\3\u0099\3") + buf.write("\u0099\3\u0099\3\u0099\5\u0099\u0e93\n\u0099\3\u009a\3") + buf.write("\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\5\u009a\u0eab\n\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\5\u009a\u0ebf\n\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u0ec9\n\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\5\u009a\u0edb\n\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a") + buf.write("\3\u009a\5\u009a\u0f11\n\u009a\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u0f21\n\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b") + buf.write("\u0f29\n\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u0f2e\n") + buf.write("\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b") + buf.write("\3\u009b\3\u009b\3\u009b\5\u009b\u0f40\n\u009b\3\u009c") + buf.write("\3\u009c\5\u009c\u0f44\n\u009c\3\u009c\3\u009c\3\u009c") + buf.write("\3\u009c\3\u009c\5\u009c\u0f4b\n\u009c\5\u009c\u0f4d\n") + buf.write("\u009c\3\u009c\3\u009c\3\u009d\6\u009d\u0f52\n\u009d\r") + buf.write("\u009d\16\u009d\u0f53\3\u009d\5\u009d\u0f57\n\u009d\3") + buf.write("\u009e\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f\3\u009f") + buf.write("\3\u009f\3\u009f\7\u009f\u0f62\n\u009f\f\u009f\16\u009f") + buf.write("\u0f65\13\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0") + buf.write("\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2") + buf.write("\7\u00a2\u0f73\n\u00a2\f\u00a2\16\u00a2\u0f76\13\u00a2") + buf.write("\5\u00a2\u0f78\n\u00a2\3\u00a2\5\u00a2\u0f7b\n\u00a2\3") + buf.write("\u00a2\5\u00a2\u0f7e\n\u00a2\3\u00a2\3\u00a2\3\u00a3\3") + buf.write("\u00a3\3\u00a3\3\u00a3\3\u00a3\7\u00a3\u0f87\n\u00a3\f") + buf.write("\u00a3\16\u00a3\u0f8a\13\u00a3\3\u00a4\3\u00a4\7\u00a4") + buf.write("\u0f8e\n\u00a4\f\u00a4\16\u00a4\u0f91\13\u00a4\3\u00a4") + buf.write("\3\u00a4\5\u00a4\u0f95\n\u00a4\3\u00a5\5\u00a5\u0f98\n") + buf.write("\u00a5\3\u00a5\5\u00a5\u0f9b\n\u00a5\3\u00a5\3\u00a5\3") + buf.write("\u00a5\5\u00a5\u0fa0\n\u00a5\3\u00a6\3\u00a6\3\u00a7\5") + buf.write("\u00a7\u0fa5\n\u00a7\3\u00a7\3\u00a7\5\u00a7\u0fa9\n\u00a7") + buf.write("\3\u00a7\3\u00a7\7\u00a7\u0fad\n\u00a7\f\u00a7\16\u00a7") + buf.write("\u0fb0\13\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8") + buf.write("\3\u00a8\3\u00a8\5\u00a8\u0fb9\n\u00a8\3\u00a8\3\u00a8") + buf.write("\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0fc0\n\u00a8\3\u00a8") + buf.write("\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0fc6\n\u00a8\3\u00a8") + buf.write("\3\u00a8\5\u00a8\u0fca\n\u00a8\3\u00a8\3\u00a8\3\u00a8") + buf.write("\3\u00a8\5\u00a8\u0fd0\n\u00a8\3\u00a8\3\u00a8\3\u00a8") + buf.write("\3\u00a8\5\u00a8\u0fd6\n\u00a8\3\u00a9\5\u00a9\u0fd9\n") + buf.write("\u00a9\3\u00a9\3\u00a9\3\u00aa\5\u00aa\u0fde\n\u00aa\3") + buf.write("\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ac\3\u00ac\5\u00ac") + buf.write("\u0fe6\n\u00ac\3\u00ac\5\u00ac\u0fe9\n\u00ac\3\u00ac\3") + buf.write("\u00ac\5\u00ac\u0fed\n\u00ac\3\u00ad\3\u00ad\3\u00ad\3") + buf.write("\u00ad\3\u00ad\3\u00ad\5\u00ad\u0ff5\n\u00ad\3\u00ad\3") + buf.write("\u00ad\5\u00ad\u0ff9\n\u00ad\3\u00ad\3\u00ad\3\u00ad\3") + buf.write("\u00ad\7\u00ad\u0fff\n\u00ad\f\u00ad\16\u00ad\u1002\13") + buf.write("\u00ad\5\u00ad\u1004\n\u00ad\3\u00ad\3\u00ad\5\u00ad\u1008") + buf.write("\n\u00ad\3\u00ad\3\u00ad\3\u00ad\5\u00ad\u100d\n\u00ad") + buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae") + buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae") + buf.write("\7\u00ae\u101d\n\u00ae\f\u00ae\16\u00ae\u1020\13\u00ae") + buf.write("\5\u00ae\u1022\n\u00ae\3\u00ae\3\u00ae\5\u00ae\u1026\n") + buf.write("\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u102b\n\u00ae\5") + buf.write("\u00ae\u102d\n\u00ae\3\u00af\3\u00af\5\u00af\u1031\n\u00af") + buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u1037\n\u00af") + buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0") + buf.write("\5\u00b0\u1040\n\u00b0\3\u00b1\3\u00b1\3\u00b1\3\u00b1") + buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2") + buf.write("\u104c\n\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u1051\n") + buf.write("\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2") + buf.write("\5\u00b2\u1059\n\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3") + buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3") + buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u106a\n\u00b3") + buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u1070\n\u00b3") + buf.write("\3\u00b4\3\u00b4\5\u00b4\u1074\n\u00b4\3\u00b4\3\u00b4") + buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\5\u00b4\u107c\n\u00b4") + buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b6") + buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b7") + buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\7\u00b7") + buf.write("\u1092\n\u00b7\f\u00b7\16\u00b7\u1095\13\u00b7\3\u00b7") + buf.write("\3\u00b7\3\u00b7\3\u00b7\7\u00b7\u109b\n\u00b7\f\u00b7") + buf.write("\16\u00b7\u109e\13\u00b7\5\u00b7\u10a0\n\u00b7\3\u00b8") + buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\5\u00b8\u10ab\n\u00b8\3\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\3\u00b8\5\u00b8\u10b2\n\u00b8\3\u00b8\3\u00b8") + buf.write("\3\u00b8\5\u00b8\u10b7\n\u00b8\5\u00b8\u10b9\n\u00b8\3") + buf.write("\u00b8\5\u00b8\u10bc\n\u00b8\3\u00b8\3\u00b8\5\u00b8\u10c0") + buf.write("\n\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9") + buf.write("\u10c7\n\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u10cc\n") + buf.write("\u00b9\5\u00b9\u10ce\n\u00b9\3\u00b9\3\u00b9\3\u00ba\3") + buf.write("\u00ba\3\u00ba\5\u00ba\u10d5\n\u00ba\3\u00ba\3\u00ba\3") + buf.write("\u00ba\3\u00ba\5\u00ba\u10db\n\u00ba\3\u00bb\3\u00bb\3") + buf.write("\u00bb\3\u00bb\5\u00bb\u10e1\n\u00bb\3\u00bb\3\u00bb\3") + buf.write("\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb\u10ea\n") + buf.write("\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\7\u00bb\u10f0\n") + buf.write("\u00bb\f\u00bb\16\u00bb\u10f3\13\u00bb\3\u00bc\3\u00bc") + buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u10fb\n\u00bc") + buf.write("\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u1100\n\u00bc\3\u00bc") + buf.write("\5\u00bc\u1103\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc") + buf.write("\3\u00bc\3\u00bc\5\u00bc\u110b\n\u00bc\3\u00bc\3\u00bc") + buf.write("\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u1112\n\u00bc\3\u00bc") + buf.write("\3\u00bc\3\u00bc\5\u00bc\u1117\n\u00bc\5\u00bc\u1119\n") + buf.write("\u00bc\3\u00bc\5\u00bc\u111c\n\u00bc\3\u00bc\3\u00bc\3") + buf.write("\u00bc\3\u00bc\5\u00bc\u1122\n\u00bc\3\u00bd\3\u00bd\3") + buf.write("\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd") + buf.write("\u112c\n\u00bd\3\u00be\3\u00be\3\u00be\5\u00be\u1131\n") + buf.write("\u00be\3\u00be\3\u00be\3\u00be\3\u00be\5\u00be\u1137\n") + buf.write("\u00be\3\u00bf\5\u00bf\u113a\n\u00bf\3\u00bf\3\u00bf\3") + buf.write("\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf") + buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u114a") + buf.write("\n\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1") + buf.write("\3\u00c1\7\u00c1\u1153\n\u00c1\f\u00c1\16\u00c1\u1156") + buf.write("\13\u00c1\3\u00c1\3\u00c1\3\u00c1\5\u00c1\u115b\n\u00c1") + buf.write("\3\u00c1\5\u00c1\u115e\n\u00c1\3\u00c2\3\u00c2\3\u00c2") + buf.write("\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3") + buf.write("\3\u00c3\3\u00c3\3\u00c3\7\u00c3\u116d\n\u00c3\f\u00c3") + buf.write("\16\u00c3\u1170\13\u00c3\5\u00c3\u1172\n\u00c3\3\u00c4") + buf.write("\5\u00c4\u1175\n\u00c4\3\u00c4\3\u00c4\5\u00c4\u1179\n") + buf.write("\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5") + buf.write("\3\u00c5\3\u00c5\3\u00c5\5\u00c5\u1184\n\u00c5\3\u00c6") + buf.write("\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c7\3\u00c7") + buf.write("\5\u00c7\u118e\n\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8") + buf.write("\5\u00c8\u1194\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u1198\n") + buf.write("\u00c8\3\u00c8\5\u00c8\u119b\n\u00c8\3\u00c8\3\u00c8\3") + buf.write("\u00c8\3\u00c8\3\u00c8\5\u00c8\u11a2\n\u00c8\5\u00c8\u11a4") + buf.write("\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u11a8\n\u00c8\3\u00c9") + buf.write("\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\5\u00c9\u11b0") + buf.write("\n\u00c9\3\u00c9\3\u00c9\5\u00c9\u11b4\n\u00c9\3\u00c9") + buf.write("\3\u00c9\5\u00c9\u11b8\n\u00c9\3\u00c9\5\u00c9\u11bb\n") + buf.write("\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\5\u00c9") + buf.write("\u11c2\n\u00c9\5\u00c9\u11c4\n\u00c9\3\u00ca\3\u00ca\5") + buf.write("\u00ca\u11c8\n\u00ca\3\u00ca\7\u00ca\u11cb\n\u00ca\f\u00ca") + buf.write("\16\u00ca\u11ce\13\u00ca\3\u00cb\5\u00cb\u11d1\n\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u11d6\n\u00cb\3\u00cb") + buf.write("\3\u00cb\5\u00cb\u11da\n\u00cb\3\u00cb\3\u00cb\5\u00cb") + buf.write("\u11de\n\u00cb\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u11e3\n") + buf.write("\u00cb\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u11e8\n\u00cb\3") + buf.write("\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cb\5\u00cb\u11f2\n\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u11fa\n\u00cb\3\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb") + buf.write("\3\u00cb\5\u00cb\u120c\n\u00cb\3\u00cc\3\u00cc\5\u00cc") + buf.write("\u1210\n\u00cc\3\u00cc\5\u00cc\u1213\n\u00cc\3\u00cc\5") + buf.write("\u00cc\u1216\n\u00cc\3\u00cc\5\u00cc\u1219\n\u00cc\3\u00cc") + buf.write("\3\u00cc\5\u00cc\u121d\n\u00cc\3\u00cc\3\u00cc\5\u00cc") + buf.write("\u1221\n\u00cc\3\u00cc\3\u00cc\5\u00cc\u1225\n\u00cc\3") + buf.write("\u00cc\3\u00cc\5\u00cc\u1229\n\u00cc\3\u00cc\5\u00cc\u122c") + buf.write("\n\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u1231\n\u00cc") + buf.write("\3\u00cc\3\u00cc\5\u00cc\u1235\n\u00cc\3\u00cc\5\u00cc") + buf.write("\u1238\n\u00cc\3\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce") + buf.write("\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\7\u00cf") + buf.write("\u1245\n\u00cf\f\u00cf\16\u00cf\u1248\13\u00cf\3\u00cf") + buf.write("\3\u00cf\3\u00d0\3\u00d0\5\u00d0\u124e\n\u00d0\3\u00d0") + buf.write("\3\u00d0\3\u00d0\3\u00d1\5\u00d1\u1254\n\u00d1\3\u00d1") + buf.write("\3\u00d1\5\u00d1\u1258\n\u00d1\3\u00d1\3\u00d1\5\u00d1") + buf.write("\u125c\n\u00d1\3\u00d1\3\u00d1\3\u00d1\5\u00d1\u1261\n") + buf.write("\u00d1\3\u00d1\3\u00d1\5\u00d1\u1265\n\u00d1\3\u00d1\5") + buf.write("\u00d1\u1268\n\u00d1\3\u00d1\5\u00d1\u126b\n\u00d1\3\u00d1") + buf.write("\5\u00d1\u126e\n\u00d1\3\u00d2\5\u00d2\u1271\n\u00d2\3") + buf.write("\u00d2\3\u00d2\5\u00d2\u1275\n\u00d2\3\u00d2\3\u00d2\5") + buf.write("\u00d2\u1279\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u127d\n\u00d2") + buf.write("\3\u00d2\3\u00d2\5\u00d2\u1281\n\u00d2\3\u00d2\5\u00d2") + buf.write("\u1284\n\u00d2\3\u00d2\5\u00d2\u1287\n\u00d2\3\u00d2\5") + buf.write("\u00d2\u128a\n\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5") + buf.write("\u00d2\u1290\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u1294\n\u00d2") + buf.write("\3\u00d2\5\u00d2\u1297\n\u00d2\3\u00d3\3\u00d3\3\u00d3") + buf.write("\5\u00d3\u129c\n\u00d3\3\u00d3\3\u00d3\3\u00d3\5\u00d3") + buf.write("\u12a1\n\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4") + buf.write("\5\u00d4\u12a8\n\u00d4\3\u00d5\3\u00d5\3\u00d5\3\u00d5") + buf.write("\5\u00d5\u12ae\n\u00d5\3\u00d5\3\u00d5\3\u00d6\3\u00d6") + buf.write("\3\u00d6\3\u00d6\5\u00d6\u12b6\n\u00d6\3\u00d7\3\u00d7") + buf.write("\3\u00d7\3\u00d7\3\u00d7\7\u00d7\u12bd\n\u00d7\f\u00d7") + buf.write("\16\u00d7\u12c0\13\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7") + buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7") + buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u12d1\n\u00d7") + buf.write("\3\u00d8\3\u00d8\3\u00d8\3\u00d8\7\u00d8\u12d7\n\u00d8") + buf.write("\f\u00d8\16\u00d8\u12da\13\u00d8\3\u00d8\3\u00d8\3\u00d9") + buf.write("\3\u00d9\3\u00d9\3\u00d9\7\u00d9\u12e2\n\u00d9\f\u00d9") + buf.write("\16\u00d9\u12e5\13\u00d9\5\u00d9\u12e7\n\u00d9\3\u00d9") + buf.write("\3\u00d9\3\u00d9\5\u00d9\u12ec\n\u00d9\3\u00da\3\u00da") + buf.write("\3\u00da\5\u00da\u12f1\n\u00da\3\u00db\3\u00db\3\u00db") + buf.write("\3\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\7\u00dc") + buf.write("\u12fc\n\u00dc\f\u00dc\16\u00dc\u12ff\13\u00dc\3\u00dc") + buf.write("\3\u00dc\3\u00dd\3\u00dd\5\u00dd\u1305\n\u00dd\3\u00de") + buf.write("\3\u00de\3\u00de\5\u00de\u130a\n\u00de\3\u00df\3\u00df") + buf.write("\3\u00df\3\u00df\3\u00df\7\u00df\u1311\n\u00df\f\u00df") + buf.write("\16\u00df\u1314\13\u00df\3\u00df\3\u00df\3\u00e0\5\u00e0") + buf.write("\u1319\n\u00e0\3\u00e0\3\u00e0\5\u00e0\u131d\n\u00e0\3") + buf.write("\u00e1\3\u00e1\5\u00e1\u1321\n\u00e1\3\u00e2\3\u00e2\3") + buf.write("\u00e2\3\u00e2\7\u00e2\u1327\n\u00e2\f\u00e2\16\u00e2") + buf.write("\u132a\13\u00e2\3\u00e2\3\u00e2\3\u00e3\3\u00e3\3\u00e3") + buf.write("\3\u00e3\3\u00e3\7\u00e3\u1333\n\u00e3\f\u00e3\16\u00e3") + buf.write("\u1336\13\u00e3\5\u00e3\u1338\n\u00e3\3\u00e4\3\u00e4") + buf.write("\3\u00e4\5\u00e4\u133d\n\u00e4\3\u00e4\7\u00e4\u1340\n") + buf.write("\u00e4\f\u00e4\16\u00e4\u1343\13\u00e4\3\u00e4\5\u00e4") + buf.write("\u1346\n\u00e4\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u134b\n") + buf.write("\u00e5\3\u00e5\5\u00e5\u134e\n\u00e5\3\u00e5\7\u00e5\u1351") + buf.write("\n\u00e5\f\u00e5\16\u00e5\u1354\13\u00e5\3\u00e6\3\u00e6") + buf.write("\3\u00e6\3\u00e7\3\u00e7\5\u00e7\u135b\n\u00e7\3\u00e7") + buf.write("\3\u00e7\5\u00e7\u135f\n\u00e7\3\u00e7\5\u00e7\u1362\n") + buf.write("\u00e7\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u1367\n\u00e8\3") + buf.write("\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8") + buf.write("\3\u00e8\3\u00e8\7\u00e8\u1372\n\u00e8\f\u00e8\16\u00e8") + buf.write("\u1375\13\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8") + buf.write("\u137b\n\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u1380\n") + buf.write("\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u1385\n\u00e8\3") + buf.write("\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\7\u00e8\u138c\n") + buf.write("\u00e8\f\u00e8\16\u00e8\u138f\13\u00e8\3\u00e8\3\u00e8") + buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u1397\n\u00e8") + buf.write("\3\u00e8\5\u00e8\u139a\n\u00e8\3\u00e8\3\u00e8\3\u00e8") + buf.write("\3\u00e8\5\u00e8\u13a0\n\u00e8\3\u00e8\5\u00e8\u13a3\n") + buf.write("\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8") + buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8") + buf.write("\u13b1\n\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9") + buf.write("\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9") + buf.write("\3\u00e9\5\u00e9\u13c0\n\u00e9\3\u00ea\3\u00ea\3\u00ea") + buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea") + buf.write("\3\u00ea\3\u00ea\3\u00ea\5\u00ea\u13cf\n\u00ea\3\u00eb") + buf.write("\3\u00eb\3\u00ec\5\u00ec\u13d4\n\u00ec\3\u00ec\5\u00ec") + buf.write("\u13d7\n\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\5\u00ec") + buf.write("\u13dd\n\u00ec\5\u00ec\u13df\n\u00ec\3\u00ed\3\u00ed\3") + buf.write("\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u13e8\n") + buf.write("\u00ee\f\u00ee\16\u00ee\u13eb\13\u00ee\3\u00ef\3\u00ef") + buf.write("\3\u00ef\3\u00ef\7\u00ef\u13f1\n\u00ef\f\u00ef\16\u00ef") + buf.write("\u13f4\13\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0") + buf.write("\5\u00f0\u13fb\n\u00f0\3\u00f1\3\u00f1\3\u00f1\5\u00f1") + buf.write("\u1400\n\u00f1\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3") + buf.write("\3\u00f3\3\u00f3\3\u00f3\5\u00f3\u140a\n\u00f3\3\u00f4") + buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\5\u00f4") + buf.write("\u1413\n\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6") + buf.write("\3\u00f6\3\u00f6\3\u00f6\5\u00f6\u141d\n\u00f6\3\u00f7") + buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\5\u00f7\u1424\n\u00f7") + buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9") + buf.write("\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa") + buf.write("\3\u00fa\3\u00fa\3\u00fa\5\u00fa\u1437\n\u00fa\5\u00fa") + buf.write("\u1439\n\u00fa\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc") + buf.write("\3\u00fc\3\u00fc\7\u00fc\u1442\n\u00fc\f\u00fc\16\u00fc") + buf.write("\u1445\13\u00fc\3\u00fd\3\u00fd\3\u00fe\3\u00fe\3\u00fe") + buf.write("\3\u00ff\3\u00ff\5\u00ff\u144e\n\u00ff\3\u00ff\5\u00ff") + buf.write("\u1451\n\u00ff\3\u0100\3\u0100\3\u0101\6\u0101\u1456\n") + buf.write("\u0101\r\u0101\16\u0101\u1457\3\u0101\7\u0101\u145b\n") + buf.write("\u0101\f\u0101\16\u0101\u145e\13\u0101\3\u0101\3\u0101") + buf.write("\5\u0101\u1462\n\u0101\3\u0102\3\u0102\3\u0102\3\u0102") + buf.write("\3\u0102\3\u0102\3\u0102\3\u0102\5\u0102\u146c\n\u0102") + buf.write("\3\u0102\3\u0102\5\u0102\u1470\n\u0102\3\u0102\5\u0102") + buf.write("\u1473\n\u0102\3\u0103\3\u0103\5\u0103\u1477\n\u0103\3") + buf.write("\u0103\3\u0103\5\u0103\u147b\n\u0103\3\u0103\5\u0103\u147e") + buf.write("\n\u0103\3\u0104\3\u0104\5\u0104\u1482\n\u0104\3\u0104") + buf.write("\3\u0104\3\u0104\3\u0104\5\u0104\u1488\n\u0104\3\u0105") + buf.write("\3\u0105\5\u0105\u148c\n\u0105\3\u0105\3\u0105\3\u0105") + buf.write("\3\u0105\5\u0105\u1492\n\u0105\3\u0106\3\u0106\3\u0106") + buf.write("\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106") + buf.write("\3\u0106\5\u0106\u149f\n\u0106\3\u0106\3\u0106\3\u0106") + buf.write("\3\u0106\3\u0106\3\u0106\5\u0106\u14a7\n\u0106\3\u0106") + buf.write("\5\u0106\u14aa\n\u0106\3\u0106\3\u0106\5\u0106\u14ae\n") + buf.write("\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106") + buf.write("\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106\3\u0106") + buf.write("\3\u0106\5\u0106\u14be\n\u0106\3\u0106\3\u0106\3\u0107") + buf.write("\5\u0107\u14c3\n\u0107\3\u0107\3\u0107\5\u0107\u14c7\n") + buf.write("\u0107\3\u0108\3\u0108\3\u0108\5\u0108\u14cc\n\u0108\3") + buf.write("\u0109\3\u0109\3\u0109\5\u0109\u14d1\n\u0109\3\u010a\3") + buf.write("\u010a\3\u010a\5\u010a\u14d6\n\u010a\3\u010b\3\u010b\3") + buf.write("\u010b\3\u010b\3\u010b\5\u010b\u14dd\n\u010b\3\u010c\3") + buf.write("\u010c\3\u010d\3\u010d\3\u010e\3\u010e\3\u010f\3\u010f") + buf.write("\3\u0110\3\u0110\3\u0111\3\u0111\3\u0111\3\u0111\3\u0111") + buf.write("\5\u0111\u14ee\n\u0111\3\u0112\3\u0112\3\u0112\7\u0112") + buf.write("\u14f3\n\u0112\f\u0112\16\u0112\u14f6\13\u0112\3\u0113") + buf.write("\5\u0113\u14f9\n\u0113\3\u0113\3\u0113\3\u0113\5\u0113") + buf.write("\u14fe\n\u0113\3\u0113\6\u0113\u1501\n\u0113\r\u0113\16") + buf.write("\u0113\u1502\5\u0113\u1505\n\u0113\3\u0114\3\u0114\5\u0114") + buf.write("\u1509\n\u0114\3\u0114\3\u0114\3\u0115\3\u0115\3\u0115") + buf.write("\5\u0115\u1510\n\u0115\3\u0115\5\u0115\u1513\n\u0115\3") + buf.write("\u0115\3\u0115\3\u0115\5\u0115\u1518\n\u0115\3\u0115\3") + buf.write("\u0115\5\u0115\u151c\n\u0115\3\u0115\3\u0115\3\u0115\3") + buf.write("\u0115\5\u0115\u1522\n\u0115\3\u0115\3\u0115\3\u0115\3") + buf.write("\u0115\5\u0115\u1528\n\u0115\3\u0115\5\u0115\u152b\n\u0115") + buf.write("\3\u0115\5\u0115\u152e\n\u0115\3\u0115\3\u0115\5\u0115") + buf.write("\u1532\n\u0115\3\u0115\5\u0115\u1535\n\u0115\3\u0115\3") + buf.write("\u0115\5\u0115\u1539\n\u0115\3\u0115\5\u0115\u153c\n\u0115") + buf.write("\3\u0115\3\u0115\5\u0115\u1540\n\u0115\3\u0115\3\u0115") + buf.write("\3\u0115\3\u0115\5\u0115\u1546\n\u0115\3\u0115\3\u0115") + buf.write("\3\u0115\5\u0115\u154b\n\u0115\3\u0115\3\u0115\5\u0115") + buf.write("\u154f\n\u0115\3\u0115\3\u0115\3\u0115\5\u0115\u1554\n") + buf.write("\u0115\3\u0115\3\u0115\5\u0115\u1558\n\u0115\3\u0115\3") + buf.write("\u0115\3\u0115\3\u0115\3\u0115\7\u0115\u155f\n\u0115\f") + buf.write("\u0115\16\u0115\u1562\13\u0115\3\u0115\3\u0115\5\u0115") + buf.write("\u1566\n\u0115\5\u0115\u1568\n\u0115\3\u0116\3\u0116\3") + buf.write("\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116") + buf.write("\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116") + buf.write("\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116\3\u0116") + buf.write("\3\u0116\3\u0116\3\u0116\3\u0116\5\u0116\u1585\n\u0116") + buf.write("\3\u0117\3\u0117\3\u0117\3\u0117\3\u0118\3\u0118\3\u0118") + buf.write("\3\u0118\5\u0118\u158f\n\u0118\3\u0118\3\u0118\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\5\u0119\u1598\n\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\6\u0119\u159e\n\u0119") + buf.write("\r\u0119\16\u0119\u159f\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u15ac\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\5\u0119\u15c2\n\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u15c6\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\5\u0119\u15ce\n\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\5\u0119\u15d4\n\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\5\u0119\u15d9\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\5\u0119\u15df\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u15eb\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u15ff\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\7\u0119\u1607\n\u0119\f\u0119\16\u0119\u160a") + buf.write("\13\u0119\5\u0119\u160c\n\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\5\u0119\u1613\n\u0119\3\u0119\3\u0119") + buf.write("\5\u0119\u1617\n\u0119\3\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u161c\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u1622\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\5\u0119") + buf.write("\u1628\n\u0119\3\u0119\3\u0119\3\u0119\3\u0119\3\u0119") + buf.write("\3\u0119\3\u0119\3\u0119\3\u0119\7\u0119\u1633\n\u0119") + buf.write("\f\u0119\16\u0119\u1636\13\u0119\3\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\5\u011a\u163d\n\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\6\u011a\u1643\n\u011a\r\u011a\16\u011a") + buf.write("\u1644\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\5\u011a\u164f\n\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\5\u011a\u1664\n\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\5\u011a\u1671\n\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\5\u011a\u1677\n\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\5\u011a\u167d\n\u011a\3\u011a") + buf.write("\3\u011a\3\u011a\3\u011a\3\u011a\7\u011a\u1684\n\u011a") + buf.write("\f\u011a\16\u011a\u1687\13\u011a\3\u011b\3\u011b\3\u011b") + buf.write("\3\u011b\3\u011b\3\u011b\3\u011b\3\u011b\5\u011b\u1691") + buf.write("\n\u011b\3\u011c\3\u011c\3\u011c\3\u011c\3\u011c\3\u011c") + buf.write("\3\u011c\3\u011c\5\u011c\u169b\n\u011c\3\u011d\3\u011d") + buf.write("\3\u011d\3\u011d\3\u011d\3\u011d\3\u011d\3\u011d\3\u011d") + buf.write("\3\u011d\3\u011d\3\u011d\3\u011e\3\u011e\3\u011e\3\u011e") + buf.write("\3\u011e\5\u011e\u16ae\n\u011e\3\u011e\3\u011e\3\u011e") + buf.write("\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e\3\u011e") + buf.write("\3\u011e\5\u011e\u16bb\n\u011e\3\u011f\3\u011f\3\u011f") + buf.write("\5\u011f\u16c0\n\u011f\3\u0120\3\u0120\3\u0121\3\u0121") + buf.write("\3\u0122\3\u0122\5\u0122\u16c8\n\u0122\3\u0122\3\u0122") + buf.write("\3\u0122\3\u0122\3\u0122\6\u0122\u16cf\n\u0122\r\u0122") + buf.write("\16\u0122\u16d0\3\u0122\3\u0122\5\u0122\u16d5\n\u0122") + buf.write("\3\u0122\3\u0122\3\u0123\3\u0123\3\u0123\3\u0123\3\u0123") + buf.write("\3\u0123\3\u0123\3\u0124\3\u0124\3\u0124\5\u0124\u16e3") + buf.write("\n\u0124\3\u0124\3\u0124\3\u0124\7\u0124\u16e8\n\u0124") + buf.write("\f\u0124\16\u0124\u16eb\13\u0124\3\u0124\5\u0124\u16ee") + buf.write("\n\u0124\5\u0124\u16f0\n\u0124\3\u0124\3\u0124\3\u0124") + buf.write("\3\u0124\3\u0124\3\u0124\3\u0124\5\u0124\u16f9\n\u0124") + buf.write("\3\u0124\5\u0124\u16fc\n\u0124\3\u0124\3\u0124\3\u0124") + buf.write("\5\u0124\u1701\n\u0124\5\u0124\u1703\n\u0124\3\u0124\3") + buf.write("\u0124\3\u0124\3\u0124\3\u0124\3\u0124\5\u0124\u170b\n") + buf.write("\u0124\3\u0125\5\u0125\u170e\n\u0125\3\u0125\3\u0125\3") + buf.write("\u0125\5\u0125\u1713\n\u0125\3\u0125\3\u0125\3\u0126\3") + buf.write("\u0126\3\u0127\3\u0127\3\u0127\3\u0127\3\u0127\7\u0127") + buf.write("\u171e\n\u0127\f\u0127\16\u0127\u1721\13\u0127\3\u0127") + buf.write("\3\u0127\3\u0127\3\u0127\3\u0127\3\u0127\3\u0127\7\u0127") + buf.write("\u172a\n\u0127\f\u0127\16\u0127\u172d\13\u0127\5\u0127") + buf.write("\u172f\n\u0127\3\u0127\5\u0127\u1732\n\u0127\3\u0128\3") + buf.write("\u0128\3\u0128\3\u0128\5\u0128\u1738\n\u0128\3\u0128\3") + buf.write("\u0128\3\u0128\3\u0128\3\u0129\3\u0129\3\u0129\3\u0129") + buf.write("\3\u0129\3\u0129\5\u0129\u1744\n\u0129\3\u012a\3\u012a") + buf.write("\3\u012a\5\u012a\u1749\n\u012a\3\u012a\3\u012a\5\u012a") + buf.write("\u174d\n\u012a\3\u012a\3\u012a\5\u012a\u1751\n\u012a\3") + buf.write("\u012a\3\u012a\5\u012a\u1755\n\u012a\5\u012a\u1757\n\u012a") + buf.write("\3\u012b\3\u012b\3\u012b\5\u012b\u175c\n\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\3\u012b\3\u012b\5\u012b\u1763\n\u012b") + buf.write("\3\u012b\3\u012b\3\u012b\5\u012b\u1768\n\u012b\5\u012b") + buf.write("\u176a\n\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\7\u012b\u1773\n\u012b\f\u012b\16\u012b") + buf.write("\u1776\13\u012b\3\u012b\3\u012b\5\u012b\u177a\n\u012b") + buf.write("\3\u012b\3\u012b\5\u012b\u177e\n\u012b\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\5\u012b\u1792\n\u012b\3\u012b\3\u012b") + buf.write("\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\3\u012b\5\u012b") + buf.write("\u179c\n\u012b\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u17a8") + buf.write("\n\u012c\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u17ae") + buf.write("\n\u012c\7\u012c\u17b0\n\u012c\f\u012c\16\u012c\u17b3") + buf.write("\13\u012c\3\u012c\3\u012c\5\u012c\u17b7\n\u012c\3\u012c") + buf.write("\3\u012c\7\u012c\u17bb\n\u012c\f\u012c\16\u012c\u17be") + buf.write("\13\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\5\u012c\u17c7\n\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\5\u012c\u17cd\n\u012c\7\u012c\u17cf\n\u012c\f") + buf.write("\u012c\16\u012c\u17d2\13\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u17dc") + buf.write("\n\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u17e8\n\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c") + buf.write("\u17f0\n\u012c\5\u012c\u17f2\n\u012c\3\u012c\3\u012c\3") + buf.write("\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c") + buf.write("\u17fc\n\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u1801\n") + buf.write("\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c\3\u012c") + buf.write("\3\u012c\7\u012c\u181f\n\u012c\f\u012c\16\u012c\u1822") + buf.write("\13\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u1827\n\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\3\u012c\5\u012c\u182d\n\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\5\u012c\u1832\n\u012c\3\u012c") + buf.write("\3\u012c\3\u012c\3\u012c\7\u012c\u1838\n\u012c\f\u012c") + buf.write("\16\u012c\u183b\13\u012c\3\u012c\3\u012c\5\u012c\u183f") + buf.write("\n\u012c\3\u012d\3\u012d\3\u012d\3\u012d\5\u012d\u1845") + buf.write("\n\u012d\3\u012d\3\u012d\5\u012d\u1849\n\u012d\3\u012d") + buf.write("\5\u012d\u184c\n\u012d\3\u012d\5\u012d\u184f\n\u012d\3") + buf.write("\u012d\3\u012d\5\u012d\u1853\n\u012d\3\u012e\3\u012e\3") + buf.write("\u012e\3\u012e\5\u012e\u1859\n\u012e\3\u012e\3\u012e\3") + buf.write("\u012f\3\u012f\3\u012f\3\u012f\3\u012f\3\u012f\3\u0130") + buf.write("\3\u0130\5\u0130\u1865\n\u0130\3\u0130\5\u0130\u1868\n") + buf.write("\u0130\3\u0130\5\u0130\u186b\n\u0130\3\u0130\5\u0130\u186e") + buf.write("\n\u0130\3\u0130\3\u0130\3\u0131\3\u0131\3\u0131\3\u0131") + buf.write("\3\u0131\3\u0131\3\u0131\5\u0131\u1879\n\u0131\3\u0131") + buf.write("\3\u0131\3\u0131\3\u0131\3\u0131\3\u0131\3\u0131\5\u0131") + buf.write("\u1882\n\u0131\5\u0131\u1884\n\u0131\3\u0132\3\u0132\3") + buf.write("\u0132\3\u0132\3\u0132\5\u0132\u188b\n\u0132\3\u0133\3") + buf.write("\u0133\3\u0133\5\u0133\u1890\n\u0133\3\u0134\3\u0134\3") + buf.write("\u0134\5\u0134\u1895\n\u0134\3\u0134\3\u0134\3\u0134\5") + buf.write("\u0134\u189a\n\u0134\7\u0134\u189c\n\u0134\f\u0134\16") + buf.write("\u0134\u189f\13\u0134\5\u0134\u18a1\n\u0134\3\u0134\3") + buf.write("\u0134\3\u0135\3\u0135\3\u0135\3\u0135\3\u0135\3\u0135") + buf.write("\3\u0135\5\u0135\u18ac\n\u0135\5\u0135\u18ae\n\u0135\3") + buf.write("\u0136\3\u0136\3\u0136\3\u0136\3\u0136\5\u0136\u18b5\n") + buf.write("\u0136\5\u0136\u18b7\n\u0136\3\u0137\3\u0137\3\u0138\3") + buf.write("\u0138\3\u0138\3\u0138\3\u0139\5\u0139\u18c0\n\u0139\3") + buf.write("\u0139\3\u0139\7\u0139\u18c4\n\u0139\f\u0139\16\u0139") + buf.write("\u18c7\13\u0139\3\u013a\3\u013a\3\u013a\3\u013a\5\u013a") + buf.write("\u18cd\n\u013a\3\u013a\3\u013a\3\u013a\5\u013a\u18d2\n") + buf.write("\u013a\3\u013a\3\u013a\3\u013a\5\u013a\u18d7\n\u013a\3") + buf.write("\u013a\3\u013a\5\u013a\u18db\n\u013a\3\u013a\3\u013a\3") + buf.write("\u013a\3\u013a\3\u013a\3\u013a\3\u013a\3\u013a\5\u013a") + buf.write("\u18e5\n\u013a\3\u013a\3\u013a\3\u013a\3\u013a\7\u013a") + buf.write("\u18eb\n\u013a\f\u013a\16\u013a\u18ee\13\u013a\5\u013a") + buf.write("\u18f0\n\u013a\3\u013a\3\u013a\3\u013a\5\u013a\u18f5\n") + buf.write("\u013a\5\u013a\u18f7\n\u013a\3\u013b\5\u013b\u18fa\n\u013b") + buf.write("\3\u013b\3\u013b\7\u013b\u18fe\n\u013b\f\u013b\16\u013b") + buf.write("\u1901\13\u013b\3\u013c\3\u013c\5\u013c\u1905\n\u013c") + buf.write("\3\u013c\3\u013c\3\u013c\7\u013c\u190a\n\u013c\f\u013c") + buf.write("\16\u013c\u190d\13\u013c\3\u013d\3\u013d\3\u013d\3\u013d") + buf.write("\3\u013d\7\u013d\u1914\n\u013d\f\u013d\16\u013d\u1917") + buf.write("\13\u013d\3\u013d\3\u013d\5\u013d\u191b\n\u013d\3\u013d") + buf.write("\3\u013d\5\u013d\u191f\n\u013d\3\u013d\5\u013d\u1922\n") + buf.write("\u013d\3\u013d\3\u013d\3\u013d\3\u013d\3\u013e\3\u013e") + buf.write("\3\u013e\3\u013e\3\u013e\3\u013e\5\u013e\u192e\n\u013e") + buf.write("\3\u013e\3\u013e\3\u013e\5\u013e\u1933\n\u013e\3\u013e") + buf.write("\7\u013e\u1936\n\u013e\f\u013e\16\u013e\u1939\13\u013e") + buf.write("\3\u013f\3\u013f\3\u013f\5\u013f\u193e\n\u013f\3\u013f") + buf.write("\3\u013f\3\u013f\3\u013f\3\u013f\5\u013f\u1945\n\u013f") + buf.write("\3\u013f\5\u013f\u1948\n\u013f\3\u0140\3\u0140\3\u0140") + buf.write("\3\u0140\3\u0140\3\u0140\3\u0140\7\u0140\u1951\n\u0140") + buf.write("\f\u0140\16\u0140\u1954\13\u0140\3\u0140\3\u0140\5\u0140") + buf.write("\u1958\n\u0140\5\u0140\u195a\n\u0140\3\u0140\5\u0140\u195d") + buf.write("\n\u0140\3\u0140\5\u0140\u1960\n\u0140\3\u0140\3\u0140") + buf.write("\3\u0140\3\u0140\7\u0140\u1966\n\u0140\f\u0140\16\u0140") + buf.write("\u1969\13\u0140\5\u0140\u196b\n\u0140\3\u0140\3\u0140") + buf.write("\5\u0140\u196f\n\u0140\3\u0140\5\u0140\u1972\n\u0140\3") + buf.write("\u0140\3\u0140\5\u0140\u1976\n\u0140\3\u0140\3\u0140\3") + buf.write("\u0140\3\u0140\3\u0140\3\u0140\3\u0140\3\u0140\3\u0140") + buf.write("\7\u0140\u1981\n\u0140\f\u0140\16\u0140\u1984\13\u0140") + buf.write("\5\u0140\u1986\n\u0140\3\u0140\3\u0140\5\u0140\u198a\n") + buf.write("\u0140\3\u0140\3\u0140\5\u0140\u198e\n\u0140\3\u0140\5") + buf.write("\u0140\u1991\n\u0140\3\u0141\3\u0141\3\u0141\7\u0141\u1996") + buf.write("\n\u0141\f\u0141\16\u0141\u1999\13\u0141\3\u0142\3\u0142") + buf.write("\3\u0142\3\u0142\5\u0142\u199f\n\u0142\3\u0143\3\u0143") + buf.write("\5\u0143\u19a3\n\u0143\3\u0143\5\u0143\u19a6\n\u0143\3") + buf.write("\u0143\3\u0143\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144") + buf.write("\5\u0144\u19af\n\u0144\3\u0144\5\u0144\u19b2\n\u0144\3") + buf.write("\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144") + buf.write("\3\u0144\3\u0144\5\u0144\u19bd\n\u0144\5\u0144\u19bf\n") + buf.write("\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144") + buf.write("\5\u0144\u19c7\n\u0144\5\u0144\u19c9\n\u0144\3\u0144\3") + buf.write("\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144\3\u0144") + buf.write("\3\u0144\5\u0144\u19d4\n\u0144\5\u0144\u19d6\n\u0144\3") + buf.write("\u0144\3\u0144\3\u0144\3\u0144\3\u0144\7\u0144\u19dd\n") + buf.write("\u0144\f\u0144\16\u0144\u19e0\13\u0144\3\u0145\5\u0145") + buf.write("\u19e3\n\u0145\3\u0145\3\u0145\5\u0145\u19e7\n\u0145\3") + buf.write("\u0145\5\u0145\u19ea\n\u0145\3\u0145\3\u0145\3\u0145\3") + buf.write("\u0145\3\u0145\3\u0145\7\u0145\u19f2\n\u0145\f\u0145\16") + buf.write("\u0145\u19f5\13\u0145\3\u0145\3\u0145\3\u0145\5\u0145") + buf.write("\u19fa\n\u0145\5\u0145\u19fc\n\u0145\3\u0145\5\u0145\u19ff") + buf.write("\n\u0145\3\u0145\3\u0145\3\u0145\3\u0145\5\u0145\u1a05") + buf.write("\n\u0145\3\u0145\3\u0145\3\u0145\5\u0145\u1a0a\n\u0145") + buf.write("\3\u0145\3\u0145\3\u0145\5\u0145\u1a0f\n\u0145\3\u0145") + buf.write("\3\u0145\3\u0145\3\u0145\3\u0145\7\u0145\u1a16\n\u0145") + buf.write("\f\u0145\16\u0145\u1a19\13\u0145\3\u0145\3\u0145\3\u0145") + buf.write("\5\u0145\u1a1e\n\u0145\5\u0145\u1a20\n\u0145\3\u0145\5") + buf.write("\u0145\u1a23\n\u0145\3\u0145\3\u0145\3\u0145\3\u0145\3") + buf.write("\u0145\3\u0145\5\u0145\u1a2b\n\u0145\3\u0145\3\u0145\3") + buf.write("\u0145\3\u0145\5\u0145\u1a31\n\u0145\7\u0145\u1a33\n\u0145") + buf.write("\f\u0145\16\u0145\u1a36\13\u0145\3\u0145\3\u0145\3\u0145") + buf.write("\5\u0145\u1a3b\n\u0145\3\u0145\5\u0145\u1a3e\n\u0145\3") + buf.write("\u0145\3\u0145\3\u0145\3\u0145\3\u0145\7\u0145\u1a45\n") + buf.write("\u0145\f\u0145\16\u0145\u1a48\13\u0145\3\u0145\3\u0145") + buf.write("\5\u0145\u1a4c\n\u0145\5\u0145\u1a4e\n\u0145\5\u0145\u1a50") + buf.write("\n\u0145\3\u0146\5\u0146\u1a53\n\u0146\3\u0146\3\u0146") + buf.write("\3\u0146\3\u0146\3\u0146\7\u0146\u1a5a\n\u0146\f\u0146") + buf.write("\16\u0146\u1a5d\13\u0146\3\u0146\3\u0146\5\u0146\u1a61") + buf.write("\n\u0146\3\u0147\3\u0147\3\u0147\3\u0147\3\u0147\3\u0147") + buf.write("\3\u0147\7\u0147\u1a6a\n\u0147\f\u0147\16\u0147\u1a6d") + buf.write("\13\u0147\3\u0147\3\u0147\3\u0148\3\u0148\3\u0148\3\u0148") + buf.write("\3\u0149\3\u0149\3\u0149\7\u0149\u1a78\n\u0149\f\u0149") + buf.write("\16\u0149\u1a7b\13\u0149\3\u014a\3\u014a\3\u014a\3\u014a") + buf.write("\3\u014a\3\u014a\3\u014a\5\u014a\u1a84\n\u014a\3\u014a") + buf.write("\3\u014a\3\u014a\3\u014a\5\u014a\u1a8a\n\u014a\3\u014b") + buf.write("\3\u014b\3\u014b\3\u014b\7\u014b\u1a90\n\u014b\f\u014b") + buf.write("\16\u014b\u1a93\13\u014b\3\u014c\3\u014c\3\u014c\5\u014c") + buf.write("\u1a98\n\u014c\3\u014c\3\u014c\3\u014c\5\u014c\u1a9d\n") + buf.write("\u014c\7\u014c\u1a9f\n\u014c\f\u014c\16\u014c\u1aa2\13") + buf.write("\u014c\3\u014c\3\u014c\3\u014d\3\u014d\3\u014d\3\u014d") + buf.write("\3\u014e\3\u014e\3\u014e\7\u014e\u1aad\n\u014e\f\u014e") + buf.write("\16\u014e\u1ab0\13\u014e\3\u014f\3\u014f\5\u014f\u1ab4") + buf.write("\n\u014f\3\u014f\5\u014f\u1ab7\n\u014f\3\u014f\5\u014f") + buf.write("\u1aba\n\u014f\3\u0150\3\u0150\3\u0150\3\u0150\5\u0150") + buf.write("\u1ac0\n\u0150\3\u0151\3\u0151\3\u0151\3\u0152\5\u0152") + buf.write("\u1ac6\n\u0152\3\u0152\3\u0152\3\u0152\3\u0152\3\u0152") + buf.write("\5\u0152\u1acd\n\u0152\3\u0152\3\u0152\3\u0152\5\u0152") + buf.write("\u1ad2\n\u0152\3\u0152\5\u0152\u1ad5\n\u0152\3\u0152\3") + buf.write("\u0152\3\u0152\5\u0152\u1ada\n\u0152\3\u0152\3\u0152\3") + buf.write("\u0152\5\u0152\u1adf\n\u0152\3\u0152\5\u0152\u1ae2\n\u0152") + buf.write("\3\u0152\3\u0152\5\u0152\u1ae6\n\u0152\3\u0153\3\u0153") + buf.write("\3\u0153\3\u0153\7\u0153\u1aec\n\u0153\f\u0153\16\u0153") + buf.write("\u1aef\13\u0153\3\u0153\3\u0153\3\u0154\3\u0154\5\u0154") + buf.write("\u1af5\n\u0154\3\u0155\3\u0155\5\u0155\u1af9\n\u0155\3") + buf.write("\u0155\3\u0155\3\u0155\5\u0155\u1afe\n\u0155\3\u0156\3") + buf.write("\u0156\3\u0156\3\u0156\3\u0156\3\u0156\3\u0156\3\u0156") + buf.write("\7\u0156\u1b08\n\u0156\f\u0156\16\u0156\u1b0b\13\u0156") + buf.write("\3\u0156\3\u0156\5\u0156\u1b0f\n\u0156\5\u0156\u1b11\n") + buf.write("\u0156\3\u0157\5\u0157\u1b14\n\u0157\3\u0157\3\u0157\3") + buf.write("\u0157\5\u0157\u1b19\n\u0157\3\u0157\3\u0157\5\u0157\u1b1d") + buf.write("\n\u0157\3\u0157\5\u0157\u1b20\n\u0157\3\u0157\5\u0157") + buf.write("\u1b23\n\u0157\3\u0157\3\u0157\3\u0157\3\u0157\7\u0157") + buf.write("\u1b29\n\u0157\f\u0157\16\u0157\u1b2c\13\u0157\5\u0157") + buf.write("\u1b2e\n\u0157\3\u0157\3\u0157\3\u0157\3\u0157\3\u0157") + buf.write("\5\u0157\u1b35\n\u0157\5\u0157\u1b37\n\u0157\3\u0157\3") + buf.write("\u0157\5\u0157\u1b3b\n\u0157\3\u0158\5\u0158\u1b3e\n\u0158") + buf.write("\3\u0158\3\u0158\5\u0158\u1b42\n\u0158\3\u0158\3\u0158") + buf.write("\5\u0158\u1b46\n\u0158\3\u0158\5\u0158\u1b49\n\u0158\3") + buf.write("\u0158\5\u0158\u1b4c\n\u0158\3\u0158\3\u0158\3\u0158\3") + buf.write("\u0158\7\u0158\u1b52\n\u0158\f\u0158\16\u0158\u1b55\13") + buf.write("\u0158\3\u0158\3\u0158\3\u0158\3\u0158\7\u0158\u1b5b\n") + buf.write("\u0158\f\u0158\16\u0158\u1b5e\13\u0158\5\u0158\u1b60\n") + buf.write("\u0158\3\u0158\3\u0158\3\u0158\3\u0158\3\u0158\5\u0158") + buf.write("\u1b67\n\u0158\5\u0158\u1b69\n\u0158\3\u0158\3\u0158\5") + buf.write("\u0158\u1b6d\n\u0158\3\u0159\3\u0159\3\u0159\3\u0159\5") + buf.write("\u0159\u1b73\n\u0159\3\u0159\3\u0159\3\u0159\3\u0159\7") + buf.write("\u0159\u1b79\n\u0159\f\u0159\16\u0159\u1b7c\13\u0159\3") + buf.write("\u0159\3\u0159\3\u0159\5\u0159\u1b81\n\u0159\3\u0159\3") + buf.write("\u0159\3\u0159\5\u0159\u1b86\n\u0159\3\u0159\3\u0159\3") + buf.write("\u0159\5\u0159\u1b8b\n\u0159\7\u0159\u1b8d\n\u0159\f\u0159") + buf.write("\16\u0159\u1b90\13\u0159\3\u0159\3\u0159\5\u0159\u1b94") + buf.write("\n\u0159\5\u0159\u1b96\n\u0159\3\u015a\3\u015a\3\u015a") + buf.write("\3\u015a\5\u015a\u1b9c\n\u015a\3\u015b\3\u015b\5\u015b") + buf.write("\u1ba0\n\u015b\3\u015b\3\u015b\3\u015b\7\u015b\u1ba5\n") + buf.write("\u015b\f\u015b\16\u015b\u1ba8\13\u015b\3\u015b\3\u015b") + buf.write("\5\u015b\u1bac\n\u015b\3\u015b\5\u015b\u1baf\n\u015b\3") + buf.write("\u015c\3\u015c\3\u015c\7\u015c\u1bb4\n\u015c\f\u015c\16") + buf.write("\u015c\u1bb7\13\u015c\3\u015d\3\u015d\3\u015d\3\u015d") + buf.write("\5\u015d\u1bbd\n\u015d\5\u015d\u1bbf\n\u015d\3\u015d\3") + buf.write("\u015d\3\u015d\3\u015d\3\u015d\3\u015d\5\u015d\u1bc7\n") + buf.write("\u015d\5\u015d\u1bc9\n\u015d\3\u015e\3\u015e\3\u015e\3") + buf.write("\u015e\5\u015e\u1bcf\n\u015e\3\u015f\5\u015f\u1bd2\n\u015f") + buf.write("\3\u015f\5\u015f\u1bd5\n\u015f\3\u015f\3\u015f\3\u015f") + buf.write("\5\u015f\u1bda\n\u015f\3\u015f\3\u015f\5\u015f\u1bde\n") + buf.write("\u015f\3\u0160\3\u0160\3\u0160\3\u0160\3\u0161\3\u0161") + buf.write("\7\u0161\u1be6\n\u0161\f\u0161\16\u0161\u1be9\13\u0161") + buf.write("\3\u0162\7\u0162\u1bec\n\u0162\f\u0162\16\u0162\u1bef") + buf.write("\13\u0162\3\u0162\3\u0162\3\u0162\3\u0162\3\u0163\5\u0163") + buf.write("\u1bf6\n\u0163\3\u0163\3\u0163\5\u0163\u1bfa\n\u0163\3") + buf.write("\u0163\3\u0163\5\u0163\u1bfe\n\u0163\3\u0163\3\u0163\5") + buf.write("\u0163\u1c02\n\u0163\3\u0163\3\u0163\3\u0163\3\u0163\5") + buf.write("\u0163\u1c08\n\u0163\3\u0163\5\u0163\u1c0b\n\u0163\3\u0163") + buf.write("\5\u0163\u1c0e\n\u0163\3\u0163\3\u0163\3\u0163\3\u0163") + buf.write("\3\u0163\5\u0163\u1c15\n\u0163\3\u0163\3\u0163\5\u0163") + buf.write("\u1c19\n\u0163\3\u0164\3\u0164\3\u0164\3\u0164\3\u0164") + buf.write("\3\u0164\7\u0164\u1c21\n\u0164\f\u0164\16\u0164\u1c24") + buf.write("\13\u0164\3\u0165\3\u0165\3\u0165\3\u0165\3\u0165\3\u0165") + buf.write("\3\u0165\3\u0165\3\u0165\5\u0165\u1c2f\n\u0165\3\u0166") + buf.write("\3\u0166\3\u0166\3\u0166\3\u0166\3\u0166\6\u0166\u1c37") + buf.write("\n\u0166\r\u0166\16\u0166\u1c38\3\u0167\3\u0167\3\u0167") + buf.write("\7\u0167\u1c3e\n\u0167\f\u0167\16\u0167\u1c41\13\u0167") + buf.write("\3\u0168\3\u0168\3\u0168\3\u0168\3\u0168\3\u0168\3\u0168") + buf.write("\3\u0168\3\u0168\5\u0168\u1c4c\n\u0168\3\u0169\3\u0169") + buf.write("\3\u0169\3\u0169\3\u0169\5\u0169\u1c53\n\u0169\3\u0169") + buf.write("\3\u0169\3\u0169\3\u0169\7\u0169\u1c59\n\u0169\f\u0169") + buf.write("\16\u0169\u1c5c\13\u0169\3\u0169\5\u0169\u1c5f\n\u0169") + buf.write("\3\u016a\3\u016a\5\u016a\u1c63\n\u016a\3\u016a\3\u016a") + buf.write("\3\u016a\3\u016a\7\u016a\u1c69\n\u016a\f\u016a\16\u016a") + buf.write("\u1c6c\13\u016a\3\u016b\3\u016b\3\u016b\3\u016b\3\u016c") + buf.write("\3\u016c\3\u016c\3\u016c\3\u016c\3\u016c\7\u016c\u1c78") + buf.write("\n\u016c\f\u016c\16\u016c\u1c7b\13\u016c\3\u016c\3\u016c") + buf.write("\5\u016c\u1c7f\n\u016c\5\u016c\u1c81\n\u016c\3\u016c\3") + buf.write("\u016c\3\u016c\3\u016c\3\u016c\7\u016c\u1c88\n\u016c\f") + buf.write("\u016c\16\u016c\u1c8b\13\u016c\5\u016c\u1c8d\n\u016c\3") + buf.write("\u016c\3\u016c\5\u016c\u1c91\n\u016c\3\u016c\5\u016c\u1c94") + buf.write("\n\u016c\3\u016c\3\u016c\5\u016c\u1c98\n\u016c\3\u016c") + buf.write("\3\u016c\3\u016c\3\u016c\3\u016c\3\u016c\3\u016c\3\u016c") + buf.write("\3\u016c\7\u016c\u1ca3\n\u016c\f\u016c\16\u016c\u1ca6") + buf.write("\13\u016c\5\u016c\u1ca8\n\u016c\3\u016c\3\u016c\5\u016c") + buf.write("\u1cac\n\u016c\3\u016c\5\u016c\u1caf\n\u016c\3\u016c\7") + buf.write("\u016c\u1cb2\n\u016c\f\u016c\16\u016c\u1cb5\13\u016c\3") + buf.write("\u016d\3\u016d\3\u016d\3\u016d\5\u016d\u1cbb\n\u016d\3") + buf.write("\u016e\3\u016e\3\u016e\5\u016e\u1cc0\n\u016e\3\u016f\3") + buf.write("\u016f\3\u016f\3\u016f\3\u016f\3\u016f\5\u016f\u1cc8\n") + buf.write("\u016f\3\u0170\3\u0170\3\u0170\5\u0170\u1ccd\n\u0170\3") + buf.write("\u0170\5\u0170\u1cd0\n\u0170\3\u0170\3\u0170\3\u0170\3") + buf.write("\u0170\3\u0170\3\u0170\3\u0170\3\u0170\3\u0170\7\u0170") + buf.write("\u1cdb\n\u0170\f\u0170\16\u0170\u1cde\13\u0170\3\u0170") + buf.write("\3\u0170\5\u0170\u1ce2\n\u0170\3\u0170\3\u0170\5\u0170") + buf.write("\u1ce6\n\u0170\3\u0170\5\u0170\u1ce9\n\u0170\3\u0170\3") + buf.write("\u0170\3\u0170\5\u0170\u1cee\n\u0170\3\u0170\5\u0170\u1cf1") + buf.write("\n\u0170\3\u0170\3\u0170\3\u0170\5\u0170\u1cf6\n\u0170") + buf.write("\3\u0171\3\u0171\3\u0171\5\u0171\u1cfb\n\u0171\3\u0171") + buf.write("\3\u0171\3\u0172\3\u0172\3\u0172\5\u0172\u1d02\n\u0172") + buf.write("\3\u0172\5\u0172\u1d05\n\u0172\3\u0172\5\u0172\u1d08\n") + buf.write("\u0172\3\u0173\3\u0173\5\u0173\u1d0c\n\u0173\3\u0173\3") + buf.write("\u0173\3\u0173\7\u0173\u1d11\n\u0173\f\u0173\16\u0173") + buf.write("\u1d14\13\u0173\5\u0173\u1d16\n\u0173\3\u0173\5\u0173") + buf.write("\u1d19\n\u0173\3\u0173\3\u0173\5\u0173\u1d1d\n\u0173\3") + buf.write("\u0173\3\u0173\5\u0173\u1d21\n\u0173\3\u0173\3\u0173\5") + buf.write("\u0173\u1d25\n\u0173\3\u0173\3\u0173\3\u0173\5\u0173\u1d2a") + buf.write("\n\u0173\3\u0173\3\u0173\3\u0173\3\u0173\5\u0173\u1d30") + buf.write("\n\u0173\5\u0173\u1d32\n\u0173\3\u0174\3\u0174\3\u0175") + buf.write("\3\u0175\3\u0175\3\u0175\3\u0175\3\u0175\3\u0175\3\u0175") + buf.write("\3\u0175\7\u0175\u1d3f\n\u0175\f\u0175\16\u0175\u1d42") + buf.write("\13\u0175\3\u0176\3\u0176\3\u0177\3\u0177\5\u0177\u1d48") + buf.write("\n\u0177\3\u0177\3\u0177\3\u0177\3\u0177\3\u0177\3\u0177") + buf.write("\5\u0177\u1d50\n\u0177\3\u0178\5\u0178\u1d53\n\u0178\3") + buf.write("\u0178\5\u0178\u1d56\n\u0178\3\u0178\3\u0178\3\u0178\3") + buf.write("\u0178\3\u0178\5\u0178\u1d5d\n\u0178\3\u0178\3\u0178\5") + buf.write("\u0178\u1d61\n\u0178\3\u0178\3\u0178\5\u0178\u1d65\n\u0178") + buf.write("\5\u0178\u1d67\n\u0178\3\u0179\3\u0179\3\u0179\3\u0179") + buf.write("\3\u0179\3\u0179\5\u0179\u1d6f\n\u0179\3\u0179\3\u0179") + buf.write("\3\u0179\3\u0179\3\u0179\5\u0179\u1d76\n\u0179\3\u0179") + buf.write("\3\u0179\3\u0179\3\u0179\3\u0179\3\u0179\3\u0179\3\u0179") + buf.write("\3\u0179\3\u0179\3\u0179\3\u0179\3\u0179\7\u0179\u1d85") + buf.write("\n\u0179\f\u0179\16\u0179\u1d88\13\u0179\3\u0179\3\u0179") + buf.write("\5\u0179\u1d8c\n\u0179\3\u0179\3\u0179\3\u0179\3\u0179") + buf.write("\5\u0179\u1d92\n\u0179\3\u0179\3\u0179\3\u0179\3\u0179") + buf.write("\5\u0179\u1d98\n\u0179\3\u017a\3\u017a\3\u017a\3\u017a") + buf.write("\7\u017a\u1d9e\n\u017a\f\u017a\16\u017a\u1da1\13\u017a") + buf.write("\3\u017b\3\u017b\3\u017b\3\u017b\3\u017b\3\u017b\3\u017b") + buf.write("\3\u017b\3\u017b\7\u017b\u1dac\n\u017b\f\u017b\16\u017b") + buf.write("\u1daf\13\u017b\3\u017b\3\u017b\5\u017b\u1db3\n\u017b") + buf.write("\3\u017b\3\u017b\3\u017b\3\u017c\3\u017c\5\u017c\u1dba") + buf.write("\n\u017c\3\u017c\3\u017c\3\u017c\3\u017c\7\u017c\u1dc0") + buf.write("\n\u017c\f\u017c\16\u017c\u1dc3\13\u017c\3\u017c\3\u017c") + buf.write("\3\u017c\6\u017c\u1dc8\n\u017c\r\u017c\16\u017c\u1dc9") + buf.write("\3\u017c\3\u017c\5\u017c\u1dce\n\u017c\3\u017c\3\u017c") + buf.write("\3\u017c\3\u017d\3\u017d\3\u017d\3\u017d\5\u017d\u1dd7") + buf.write("\n\u017d\3\u017d\2\6\u0230\u0232\u027a\u0286\u017e\2\4") + buf.write("\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64") + buf.write("\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084") + buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096") + buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8") + buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba") + buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc") + buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de") + buf.write("\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0") + buf.write("\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102") + buf.write("\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114") + buf.write("\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126") + buf.write("\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138") + buf.write("\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a") + buf.write("\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c") + buf.write("\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e") + buf.write("\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180") + buf.write("\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192") + buf.write("\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4") + buf.write("\u01a6\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6") + buf.write("\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4\u01c6\u01c8") + buf.write("\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da") + buf.write("\u01dc\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec") + buf.write("\u01ee\u01f0\u01f2\u01f4\u01f6\u01f8\u01fa\u01fc\u01fe") + buf.write("\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210") + buf.write("\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222") + buf.write("\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u0234") + buf.write("\u0236\u0238\u023a\u023c\u023e\u0240\u0242\u0244\u0246") + buf.write("\u0248\u024a\u024c\u024e\u0250\u0252\u0254\u0256\u0258") + buf.write("\u025a\u025c\u025e\u0260\u0262\u0264\u0266\u0268\u026a") + buf.write("\u026c\u026e\u0270\u0272\u0274\u0276\u0278\u027a\u027c") + buf.write("\u027e\u0280\u0282\u0284\u0286\u0288\u028a\u028c\u028e") + buf.write("\u0290\u0292\u0294\u0296\u0298\u029a\u029c\u029e\u02a0") + buf.write("\u02a2\u02a4\u02a6\u02a8\u02aa\u02ac\u02ae\u02b0\u02b2") + buf.write("\u02b4\u02b6\u02b8\u02ba\u02bc\u02be\u02c0\u02c2\u02c4") + buf.write("\u02c6\u02c8\u02ca\u02cc\u02ce\u02d0\u02d2\u02d4\u02d6") + buf.write("\u02d8\u02da\u02dc\u02de\u02e0\u02e2\u02e4\u02e6\u02e8") + buf.write("\u02ea\u02ec\u02ee\u02f0\u02f2\u02f4\u02f6\u02f8\2m\4") + buf.write("\2\u0104\u0104\u0120\u0120\6\2\3\3&&\u00d4\u00d4\u018d") + buf.write("\u018d\4\2\5\5\u0144\u0144\4\2\u0112\u0112\u0144\u0144") + buf.write("\4\2\u0093\u0093\u0190\u0190\4\2\u0193\u0193\u0197\u0197") + buf.write("\7\2\u00b1\u00b1\u00e2\u00e2\u00ff\u00ff\u0101\u0101\u0170") + buf.write("\u0170\7\2\67\67qq\u00db\u00db\u00fc\u00fc\u01af\u01af") + buf.write("\4\2\u011f\u011f\u01bc\u01bc\t\2\u016f\u016f\u0172\u0172") + buf.write("\u01bf\u01bf\u01c7\u01c7\u020d\u020d\u0217\u0217\u0219") + buf.write("\u0219\6\2\u0102\u0102\u0123\u0123\u01df\u01df\u021f\u021f") + buf.write("\t\2\u0107\u0107\u015f\u0160\u016f\u016f\u0172\u0172\u01cc") + buf.write("\u01cc\u01db\u01db\u0210\u0210\4\2\u016f\u016f\u0210\u0210") + buf.write("\7\2\u009f\u009f\u018f\u018f\u01a3\u01a3\u01b3\u01b3\u0262") + buf.write("\u0262\4\2\4\4\u00c8\u00c8\4\2\u0170\u0170\u0262\u0262") + buf.write("\4\2^^\u00ba\u00ba\4\2\7\7II\4\2DDKK\4\2\r\r\u00cd\u00cd") + buf.write("\4\2\"\"\u00a0\u00a0\4\2\u0089\u0089\u0110\u0110\6\2W") + buf.write("W\u01ce\u01ce\u01e8\u01e8\u01ff\u01ff\4\2<>xx\u0112\u0112\u01ab\u01ab") + buf.write("\4\2\13\13yy\4\2\u00f1\u00f1\u0144\u0144\4\2\u0096\u0096") + buf.write("\u00a1\u00a1\4\2\u0193\u0193\u01b1\u01b1\5\2^^\u00ba\u00ba") + buf.write("\u00d6\u00d6\7\2__\u00bb\u00bb\u00d7\u00d7\u00e2\u00e2") + buf.write("\u00fd\u00fd\6\2\n\n^^\u00ba\u00ba\u00d6\u00d6\4\2 X") + buf.write("X\4\2\u0187\u0187\u0242\u0242\6\2\u0135\u0135\u013f\u013f") + buf.write("\u0197\u0197\u01b8\u01b8\4\2\u00ff\u00ff\u0101\u0101\5") + buf.write("\2\u0128\u0128\u0137\u0137\u0146\u0146\3\2\u024d\u024e") + buf.write("\4\2\u01fe\u01fe\u0208\u0208\7\2>>xx\u0112\u0112\u0170") + buf.write("\u0170\u01ab\u01ab\4\2^^\u00a2\u00a2\5\2\7\7II\u00e6\u00e6") + buf.write("\5\2\61\61\u0102\u0102\u015a\u015a\4\2\33\33\u0085\u0085") + buf.write("\4\2aa\u0085\u0085\5\2\u00bf\u00bf\u01d7\u01d7\u01e5\u01e5") + buf.write("\4\2RRoo\n\2%%++;;``hhrr\u00f5\u00f5\u0170\u0170\5\2\u00ad") + buf.write("\u00ad\u00ea\u00ea\u0160\u0160\4\2>>\u0112\u0112\5\2\u025b") + buf.write("\u025c\u025e\u025e\u0261\u0261\4\2\u0187\u0187\u01a1\u01a1") + buf.write("\5\2\u0112\u0112\u01ab\u01ab\u021d\u021d\4\2\32\32\u00d0") + buf.write("\u00d0\3\2\3\u0126\3\2\u0127\u0158\3\2\u0159\u016f\3\2") + buf.write("\u0170\u01bc\3\2\u01bd\u0240\3\2\u012b\u012c\3\2\u024f") + buf.write("\u0251\4\2\u0178\u0178\u01ae\u01ae\4\2\u0242\u0242\u0246") + buf.write("\u024a\3\2\u0262\u0263\5\2\u018f\u018f\u01a3\u01a3\u01b3") + buf.write("\u01b3\4\2\u014a\u014a\u017b\u017b\3\2\u0259\u025a\7\2") + buf.write("\u012d\u012d\u0133\u0134\u0139\u0139\u013d\u013d\u014f") + buf.write("\u014f\5\2\u0179\u0179\u019c\u019c\u01b2\u01b2\5\2\u0170") + buf.write("\u0170\u0174\u0174\u01ad\u01ad\5\2cc\u00bf\u00bf\u00d8") + buf.write("\u00d8\4\2[[\u00b3\u00b3\4\2\u0170\u0170\u018a\u018a\4") + buf.write("\2\u00d8\u00d8\u0144\u0144\4\2ZZ\u0097\u0097\5\2\u018e") + buf.write("\u018e\u0199\u0199\u01b4\u01b4\5\2\u00ff\u00ff\u0101\u0101") + buf.write("\u0110\u0110\5\2\u0160\u0160\u0166\u0166\u016c\u016c\4") + buf.write("\2ZZ\u0080\u0080\4\2\u00fc\u00fc\u01b6\u01b6\4\2--\u00cf") + buf.write("\u00cf\5\2\u0187\u0187\u0242\u0242\u025a\u025a\4\2\u0163") + buf.write("\u0163\u0191\u0191\4\2\63\63\u023e\u023e\4\2\u0242\u0242") + buf.write("\u025a\u025a\4\2&&\u00d4\u00d4\7\2\u0224\u0224\u022b\u022b") + buf.write("\u022f\u0230\u0233\u0233\u023f\u023f\n\2\u00db\u00db\u017e") + buf.write("\u017f\u01af\u01af\u0223\u0223\u0225\u0225\u0229\u0229") + buf.write("\u022e\u022e\u0232\u0232\4\2--\u022a\u022a\3\2\u0227\u0228") + buf.write("\2\u230e\2\u02fb\3\2\2\2\4\u0313\3\2\2\2\6\u0317\3\2\2") + buf.write("\2\b\u031c\3\2\2\2\n\u0327\3\2\2\2\f\u0337\3\2\2\2\16") + buf.write("\u033f\3\2\2\2\20\u0345\3\2\2\2\22\u0349\3\2\2\2\24\u0384") + buf.write("\3\2\2\2\26\u0399\3\2\2\2\30\u039b\3\2\2\2\32\u03bc\3") + buf.write("\2\2\2\34\u03d9\3\2\2\2\36\u0459\3\2\2\2 \u045b\3\2\2") + buf.write("\2\"\u0479\3\2\2\2$\u047b\3\2\2\2&\u048a\3\2\2\2(\u04a0") + buf.write("\3\2\2\2*\u04b7\3\2\2\2,\u04bc\3\2\2\2.\u04be\3\2\2\2") + buf.write("\60\u04c6\3\2\2\2\62\u04eb\3\2\2\2\64\u04ed\3\2\2\2\66") + buf.write("\u04f1\3\2\2\28\u04f5\3\2\2\2:\u0508\3\2\2\2<\u050d\3") + buf.write("\2\2\2>\u053d\3\2\2\2@\u053f\3\2\2\2B\u0562\3\2\2\2D\u0570") + buf.write("\3\2\2\2F\u0587\3\2\2\2H\u05a5\3\2\2\2J\u05ab\3\2\2\2") + buf.write("L\u05ba\3\2\2\2N\u0616\3\2\2\2P\u0618\3\2\2\2R\u061d\3") + buf.write("\2\2\2T\u0626\3\2\2\2V\u06c3\3\2\2\2X\u06f1\3\2\2\2Z\u06f3") + buf.write("\3\2\2\2\\\u0715\3\2\2\2^\u0717\3\2\2\2`\u0719\3\2\2\2") + buf.write("b\u071d\3\2\2\2d\u0727\3\2\2\2f\u072b\3\2\2\2h\u0766\3") + buf.write("\2\2\2j\u0768\3\2\2\2l\u0784\3\2\2\2n\u07ad\3\2\2\2p\u07af") + buf.write("\3\2\2\2r\u07c2\3\2\2\2t\u0801\3\2\2\2v\u0805\3\2\2\2") + buf.write("x\u081c\3\2\2\2z\u0834\3\2\2\2|\u0840\3\2\2\2~\u0842\3") + buf.write("\2\2\2\u0080\u0868\3\2\2\2\u0082\u0881\3\2\2\2\u0084\u088e") + buf.write("\3\2\2\2\u0086\u0890\3\2\2\2\u0088\u08c2\3\2\2\2\u008a") + buf.write("\u08e6\3\2\2\2\u008c\u08e8\3\2\2\2\u008e\u08ec\3\2\2\2") + buf.write("\u0090\u08f0\3\2\2\2\u0092\u0905\3\2\2\2\u0094\u0914\3") + buf.write("\2\2\2\u0096\u0918\3\2\2\2\u0098\u0924\3\2\2\2\u009a\u0927") + buf.write("\3\2\2\2\u009c\u0946\3\2\2\2\u009e\u095c\3\2\2\2\u00a0") + buf.write("\u097b\3\2\2\2\u00a2\u0a12\3\2\2\2\u00a4\u0a21\3\2\2\2") + buf.write("\u00a6\u0a35\3\2\2\2\u00a8\u0a46\3\2\2\2\u00aa\u0a4a\3") + buf.write("\2\2\2\u00ac\u0a59\3\2\2\2\u00ae\u0a70\3\2\2\2\u00b0\u0a93") + buf.write("\3\2\2\2\u00b2\u0aa8\3\2\2\2\u00b4\u0aba\3\2\2\2\u00b6") + buf.write("\u0abc\3\2\2\2\u00b8\u0acb\3\2\2\2\u00ba\u0ad7\3\2\2\2") + buf.write("\u00bc\u0ae9\3\2\2\2\u00be\u0b0f\3\2\2\2\u00c0\u0b11\3") + buf.write("\2\2\2\u00c2\u0b1c\3\2\2\2\u00c4\u0b1e\3\2\2\2\u00c6\u0b3f") + buf.write("\3\2\2\2\u00c8\u0b56\3\2\2\2\u00ca\u0b58\3\2\2\2\u00cc") + buf.write("\u0b5f\3\2\2\2\u00ce\u0b76\3\2\2\2\u00d0\u0b78\3\2\2\2") + buf.write("\u00d2\u0b89\3\2\2\2\u00d4\u0b8b\3\2\2\2\u00d6\u0b8f\3") + buf.write("\2\2\2\u00d8\u0b9c\3\2\2\2\u00da\u0ba9\3\2\2\2\u00dc\u0bb8") + buf.write("\3\2\2\2\u00de\u0bc7\3\2\2\2\u00e0\u0bd6\3\2\2\2\u00e2") + buf.write("\u0beb\3\2\2\2\u00e4\u0bf3\3\2\2\2\u00e6\u0c04\3\2\2\2") + buf.write("\u00e8\u0c08\3\2\2\2\u00ea\u0c1f\3\2\2\2\u00ec\u0c28\3") + buf.write("\2\2\2\u00ee\u0c36\3\2\2\2\u00f0\u0c38\3\2\2\2\u00f2\u0c46") + buf.write("\3\2\2\2\u00f4\u0c48\3\2\2\2\u00f6\u0c5e\3\2\2\2\u00f8") + buf.write("\u0c70\3\2\2\2\u00fa\u0c8e\3\2\2\2\u00fc\u0c91\3\2\2\2") + buf.write("\u00fe\u0ca1\3\2\2\2\u0100\u0cb6\3\2\2\2\u0102\u0cba\3") + buf.write("\2\2\2\u0104\u0d0c\3\2\2\2\u0106\u0d0e\3\2\2\2\u0108\u0d36") + buf.write("\3\2\2\2\u010a\u0d55\3\2\2\2\u010c\u0d60\3\2\2\2\u010e") + buf.write("\u0d64\3\2\2\2\u0110\u0d8d\3\2\2\2\u0112\u0d90\3\2\2\2") + buf.write("\u0114\u0dce\3\2\2\2\u0116\u0dd5\3\2\2\2\u0118\u0df0\3") + buf.write("\2\2\2\u011a\u0e23\3\2\2\2\u011c\u0e25\3\2\2\2\u011e\u0e2d") + buf.write("\3\2\2\2\u0120\u0e32\3\2\2\2\u0122\u0e4a\3\2\2\2\u0124") + buf.write("\u0e61\3\2\2\2\u0126\u0e63\3\2\2\2\u0128\u0e6a\3\2\2\2") + buf.write("\u012a\u0e6f\3\2\2\2\u012c\u0e78\3\2\2\2\u012e\u0e7c\3") + buf.write("\2\2\2\u0130\u0e84\3\2\2\2\u0132\u0f10\3\2\2\2\u0134\u0f3f") + buf.write("\3\2\2\2\u0136\u0f43\3\2\2\2\u0138\u0f51\3\2\2\2\u013a") + buf.write("\u0f58\3\2\2\2\u013c\u0f5c\3\2\2\2\u013e\u0f68\3\2\2\2") + buf.write("\u0140\u0f6b\3\2\2\2\u0142\u0f6e\3\2\2\2\u0144\u0f81\3") + buf.write("\2\2\2\u0146\u0f94\3\2\2\2\u0148\u0f97\3\2\2\2\u014a\u0fa1") + buf.write("\3\2\2\2\u014c\u0fa4\3\2\2\2\u014e\u0fd5\3\2\2\2\u0150") + buf.write("\u0fd8\3\2\2\2\u0152\u0fdd\3\2\2\2\u0154\u0fe1\3\2\2\2") + buf.write("\u0156\u0fe3\3\2\2\2\u0158\u0fee\3\2\2\2\u015a\u102c\3") + buf.write("\2\2\2\u015c\u102e\3\2\2\2\u015e\u1038\3\2\2\2\u0160\u1041") + buf.write("\3\2\2\2\u0162\u1058\3\2\2\2\u0164\u105a\3\2\2\2\u0166") + buf.write("\u1071\3\2\2\2\u0168\u107d\3\2\2\2\u016a\u1083\3\2\2\2") + buf.write("\u016c\u109f\3\2\2\2\u016e\u10bf\3\2\2\2\u0170\u10c1\3") + buf.write("\2\2\2\u0172\u10d1\3\2\2\2\u0174\u10dc\3\2\2\2\u0176\u1121") + buf.write("\3\2\2\2\u0178\u1123\3\2\2\2\u017a\u112d\3\2\2\2\u017c") + buf.write("\u1139\3\2\2\2\u017e\u1144\3\2\2\2\u0180\u114b\3\2\2\2") + buf.write("\u0182\u115f\3\2\2\2\u0184\u1171\3\2\2\2\u0186\u1174\3") + buf.write("\2\2\2\u0188\u117a\3\2\2\2\u018a\u1185\3\2\2\2\u018c\u118d") + buf.write("\3\2\2\2\u018e\u118f\3\2\2\2\u0190\u11a9\3\2\2\2\u0192") + buf.write("\u11c5\3\2\2\2\u0194\u120b\3\2\2\2\u0196\u120f\3\2\2\2") + buf.write("\u0198\u1239\3\2\2\2\u019a\u123c\3\2\2\2\u019c\u1240\3") + buf.write("\2\2\2\u019e\u124b\3\2\2\2\u01a0\u1257\3\2\2\2\u01a2\u1274") + buf.write("\3\2\2\2\u01a4\u1298\3\2\2\2\u01a6\u12a7\3\2\2\2\u01a8") + buf.write("\u12a9\3\2\2\2\u01aa\u12b5\3\2\2\2\u01ac\u12d0\3\2\2\2") + buf.write("\u01ae\u12d2\3\2\2\2\u01b0\u12dd\3\2\2\2\u01b2\u12ed\3") + buf.write("\2\2\2\u01b4\u12f2\3\2\2\2\u01b6\u12f6\3\2\2\2\u01b8\u1302") + buf.write("\3\2\2\2\u01ba\u1306\3\2\2\2\u01bc\u130b\3\2\2\2\u01be") + buf.write("\u1318\3\2\2\2\u01c0\u1320\3\2\2\2\u01c2\u1322\3\2\2\2") + buf.write("\u01c4\u1337\3\2\2\2\u01c6\u1345\3\2\2\2\u01c8\u1347\3") + buf.write("\2\2\2\u01ca\u1355\3\2\2\2\u01cc\u135a\3\2\2\2\u01ce\u13b0") + buf.write("\3\2\2\2\u01d0\u13bf\3\2\2\2\u01d2\u13ce\3\2\2\2\u01d4") + buf.write("\u13d0\3\2\2\2\u01d6\u13d3\3\2\2\2\u01d8\u13e0\3\2\2\2") + buf.write("\u01da\u13e4\3\2\2\2\u01dc\u13ec\3\2\2\2\u01de\u13f7\3") + buf.write("\2\2\2\u01e0\u13fc\3\2\2\2\u01e2\u1401\3\2\2\2\u01e4\u1409") + buf.write("\3\2\2\2\u01e6\u140b\3\2\2\2\u01e8\u1414\3\2\2\2\u01ea") + buf.write("\u141c\3\2\2\2\u01ec\u141e\3\2\2\2\u01ee\u1425\3\2\2\2") + buf.write("\u01f0\u1429\3\2\2\2\u01f2\u1438\3\2\2\2\u01f4\u143a\3") + buf.write("\2\2\2\u01f6\u143c\3\2\2\2\u01f8\u1446\3\2\2\2\u01fa\u1448") + buf.write("\3\2\2\2\u01fc\u144d\3\2\2\2\u01fe\u1452\3\2\2\2\u0200") + buf.write("\u1461\3\2\2\2\u0202\u1472\3\2\2\2\u0204\u1474\3\2\2\2") + buf.write("\u0206\u147f\3\2\2\2\u0208\u1489\3\2\2\2\u020a\u14bd\3") + buf.write("\2\2\2\u020c\u14c2\3\2\2\2\u020e\u14cb\3\2\2\2\u0210\u14d0") + buf.write("\3\2\2\2\u0212\u14d5\3\2\2\2\u0214\u14dc\3\2\2\2\u0216") + buf.write("\u14de\3\2\2\2\u0218\u14e0\3\2\2\2\u021a\u14e2\3\2\2\2") + buf.write("\u021c\u14e4\3\2\2\2\u021e\u14e6\3\2\2\2\u0220\u14ed\3") + buf.write("\2\2\2\u0222\u14ef\3\2\2\2\u0224\u14f8\3\2\2\2\u0226\u1506") + buf.write("\3\2\2\2\u0228\u1567\3\2\2\2\u022a\u1584\3\2\2\2\u022c") + buf.write("\u1586\3\2\2\2\u022e\u158a\3\2\2\2\u0230\u15ab\3\2\2\2") + buf.write("\u0232\u164e\3\2\2\2\u0234\u1690\3\2\2\2\u0236\u169a\3") + buf.write("\2\2\2\u0238\u169c\3\2\2\2\u023a\u16ba\3\2\2\2\u023c\u16bf") + buf.write("\3\2\2\2\u023e\u16c1\3\2\2\2\u0240\u16c3\3\2\2\2\u0242") + buf.write("\u16c5\3\2\2\2\u0244\u16d8\3\2\2\2\u0246\u170a\3\2\2\2") + buf.write("\u0248\u170d\3\2\2\2\u024a\u1716\3\2\2\2\u024c\u1731\3") + buf.write("\2\2\2\u024e\u1733\3\2\2\2\u0250\u1743\3\2\2\2\u0252\u1756") + buf.write("\3\2\2\2\u0254\u179b\3\2\2\2\u0256\u183e\3\2\2\2\u0258") + buf.write("\u1840\3\2\2\2\u025a\u1854\3\2\2\2\u025c\u185c\3\2\2\2") + buf.write("\u025e\u1862\3\2\2\2\u0260\u1871\3\2\2\2\u0262\u188a\3") + buf.write("\2\2\2\u0264\u188c\3\2\2\2\u0266\u1891\3\2\2\2\u0268\u18ad") + buf.write("\3\2\2\2\u026a\u18af\3\2\2\2\u026c\u18b8\3\2\2\2\u026e") + buf.write("\u18ba\3\2\2\2\u0270\u18bf\3\2\2\2\u0272\u18f6\3\2\2\2") + buf.write("\u0274\u18f9\3\2\2\2\u0276\u1902\3\2\2\2\u0278\u190e\3") + buf.write("\2\2\2\u027a\u192d\3\2\2\2\u027c\u1947\3\2\2\2\u027e\u1990") + buf.write("\3\2\2\2\u0280\u1992\3\2\2\2\u0282\u199a\3\2\2\2\u0284") + buf.write("\u19a0\3\2\2\2\u0286\u19b1\3\2\2\2\u0288\u1a4f\3\2\2\2") + buf.write("\u028a\u1a52\3\2\2\2\u028c\u1a62\3\2\2\2\u028e\u1a70\3") + buf.write("\2\2\2\u0290\u1a74\3\2\2\2\u0292\u1a89\3\2\2\2\u0294\u1a8b") + buf.write("\3\2\2\2\u0296\u1a94\3\2\2\2\u0298\u1aa5\3\2\2\2\u029a") + buf.write("\u1aa9\3\2\2\2\u029c\u1ab1\3\2\2\2\u029e\u1abf\3\2\2\2") + buf.write("\u02a0\u1ac1\3\2\2\2\u02a2\u1ac5\3\2\2\2\u02a4\u1ae7\3") + buf.write("\2\2\2\u02a6\u1af2\3\2\2\2\u02a8\u1afd\3\2\2\2\u02aa\u1b10") + buf.write("\3\2\2\2\u02ac\u1b13\3\2\2\2\u02ae\u1b3d\3\2\2\2\u02b0") + buf.write("\u1b95\3\2\2\2\u02b2\u1b97\3\2\2\2\u02b4\u1b9d\3\2\2\2") + buf.write("\u02b6\u1bb0\3\2\2\2\u02b8\u1bc8\3\2\2\2\u02ba\u1bca\3") + buf.write("\2\2\2\u02bc\u1bd1\3\2\2\2\u02be\u1bdf\3\2\2\2\u02c0\u1be3") + buf.write("\3\2\2\2\u02c2\u1bed\3\2\2\2\u02c4\u1c18\3\2\2\2\u02c6") + buf.write("\u1c1a\3\2\2\2\u02c8\u1c2e\3\2\2\2\u02ca\u1c30\3\2\2\2") + buf.write("\u02cc\u1c3f\3\2\2\2\u02ce\u1c4b\3\2\2\2\u02d0\u1c5e\3") + buf.write("\2\2\2\u02d2\u1c62\3\2\2\2\u02d4\u1c6d\3\2\2\2\u02d6\u1c80") + buf.write("\3\2\2\2\u02d8\u1cb6\3\2\2\2\u02da\u1cbc\3\2\2\2\u02dc") + buf.write("\u1cc7\3\2\2\2\u02de\u1cf5\3\2\2\2\u02e0\u1cfa\3\2\2\2") + buf.write("\u02e2\u1d07\3\2\2\2\u02e4\u1d31\3\2\2\2\u02e6\u1d33\3") + buf.write("\2\2\2\u02e8\u1d35\3\2\2\2\u02ea\u1d43\3\2\2\2\u02ec\u1d4f") + buf.write("\3\2\2\2\u02ee\u1d66\3\2\2\2\u02f0\u1d97\3\2\2\2\u02f2") + buf.write("\u1d99\3\2\2\2\u02f4\u1da2\3\2\2\2\u02f6\u1db7\3\2\2\2") + buf.write("\u02f8\u1dd6\3\2\2\2\u02fa\u02fc\7\u026d\2\2\u02fb\u02fa") + buf.write("\3\2\2\2\u02fb\u02fc\3\2\2\2\u02fc\u0300\3\2\2\2\u02fd") + buf.write("\u02ff\7\u0244\2\2\u02fe\u02fd\3\2\2\2\u02ff\u0302\3\2") + buf.write("\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2\2\2\u0301\u030e") + buf.write("\3\2\2\2\u0302\u0300\3\2\2\2\u0303\u030a\5\16\b\2\u0304") + buf.write("\u0306\7\u0244\2\2\u0305\u0304\3\2\2\2\u0306\u0307\3\2") + buf.write("\2\2\u0307\u0305\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u030b") + buf.write("\3\2\2\2\u0309\u030b\7\2\2\3\u030a\u0305\3\2\2\2\u030a") + buf.write("\u0309\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u0303\3\2\2\2") + buf.write("\u030d\u0310\3\2\2\2\u030e\u030c\3\2\2\2\u030e\u030f\3") + buf.write("\2\2\2\u030f\u0311\3\2\2\2\u0310\u030e\3\2\2\2\u0311\u0312") + buf.write("\7\2\2\3\u0312\3\3\2\2\2\u0313\u0314\5\u026a\u0136\2\u0314") + buf.write("\u0315\7\2\2\3\u0315\5\3\2\2\2\u0316\u0318\5\u026a\u0136") + buf.write("\2\u0317\u0316\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u0319") + buf.write("\3\2\2\2\u0319\u031a\5\u0142\u00a2\2\u031a\u031b\7\2\2") + buf.write("\3\u031b\7\3\2\2\2\u031c\u0321\5\u0230\u0119\2\u031d\u031e") + buf.write("\7\u0245\2\2\u031e\u0320\5\u0230\u0119\2\u031f\u031d\3") + buf.write("\2\2\2\u0320\u0323\3\2\2\2\u0321\u031f\3\2\2\2\u0321\u0322") + buf.write("\3\2\2\2\u0322\u0324\3\2\2\2\u0323\u0321\3\2\2\2\u0324") + buf.write("\u0325\7\2\2\3\u0325\t\3\2\2\2\u0326\u0328\5\u02ba\u015e") + buf.write("\2\u0327\u0326\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329") + buf.write("\3\2\2\2\u0329\u032b\5\u02bc\u015f\2\u032a\u032c\7\u0244") + buf.write("\2\2\u032b\u032a\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u032d") + buf.write("\3\2\2\2\u032d\u032e\7\2\2\3\u032e\13\3\2\2\2\u032f\u0331") + buf.write("\5\u02ba\u015e\2\u0330\u032f\3\2\2\2\u0330\u0331\3\2\2") + buf.write("\2\u0331\u0332\3\2\2\2\u0332\u0333\5\u02bc\u015f\2\u0333") + buf.write("\u0334\7\u0244\2\2\u0334\u0336\3\2\2\2\u0335\u0330\3\2") + buf.write("\2\2\u0336\u0339\3\2\2\2\u0337\u0335\3\2\2\2\u0337\u0338") + buf.write("\3\2\2\2\u0338\u033a\3\2\2\2\u0339\u0337\3\2\2\2\u033a") + buf.write("\u033b\7\2\2\3\u033b\r\3\2\2\2\u033c\u0340\5\20\t\2\u033d") + buf.write("\u0340\5<\37\2\u033e\u0340\5\22\n\2\u033f\u033c\3\2\2") + buf.write("\2\u033f\u033d\3\2\2\2\u033f\u033e\3\2\2\2\u0340\17\3") + buf.write("\2\2\2\u0341\u0346\5\u0270\u0139\2\u0342\u0346\5\u02a2") + buf.write("\u0152\2\u0343\u0346\5\u02ae\u0158\2\u0344\u0346\5\u02ac") + buf.write("\u0157\2\u0345\u0341\3\2\2\2\u0345\u0342\3\2\2\2\u0345") + buf.write("\u0343\3\2\2\2\u0345\u0344\3\2\2\2\u0346\21\3\2\2\2\u0347") + buf.write("\u034a\5\24\13\2\u0348\u034a\5\34\17\2\u0349\u0347\3\2") + buf.write("\2\2\u0349\u0348\3\2\2\2\u034a\23\3\2\2\2\u034b\u034c") + buf.write("\7\u00f0\2\2\u034c\u0352\7\u0104\2\2\u034d\u034f\7\25") + buf.write("\2\2\u034e\u0350\t\2\2\2\u034f\u034e\3\2\2\2\u034f\u0350") + buf.write("\3\2\2\2\u0350\u0352\3\2\2\2\u0351\u034b\3\2\2\2\u0351") + buf.write("\u034d\3\2\2\2\u0352\u035b\3\2\2\2\u0353\u0358\5\26\f") + buf.write("\2\u0354\u0355\7\u0245\2\2\u0355\u0357\5\26\f\2\u0356") + buf.write("\u0354\3\2\2\2\u0357\u035a\3\2\2\2\u0358\u0356\3\2\2\2") + buf.write("\u0358\u0359\3\2\2\2\u0359\u035c\3\2\2\2\u035a\u0358\3") + buf.write("\2\2\2\u035b\u0353\3\2\2\2\u035b\u035c\3\2\2\2\u035c\u0385") + buf.write("\3\2\2\2\u035d\u035f\t\3\2\2\u035e\u0360\t\2\2\2\u035f") + buf.write("\u035e\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0366\3\2\2\2") + buf.write("\u0361\u0363\7\u0173\2\2\u0362\u0364\7\u0098\2\2\u0363") + buf.write("\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\3\2\2\2") + buf.write("\u0365\u0367\7\35\2\2\u0366\u0361\3\2\2\2\u0366\u0367") + buf.write("\3\2\2\2\u0367\u0385\3\2\2\2\u0368\u0369\7&\2\2\u0369") + buf.write("\u036d\7\u00b5\2\2\u036a\u036b\7\u00b4\2\2\u036b\u036d") + buf.write("\7\u0104\2\2\u036c\u0368\3\2\2\2\u036c\u036a\3\2\2\2\u036d") + buf.write("\u036e\3\2\2\2\u036e\u0385\7\u0267\2\2\u036f\u0375\7\u00da") + buf.write("\2\2\u0370\u0372\7\u00c9\2\2\u0371\u0373\7\u00da\2\2\u0372") + buf.write("\u0371\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0375\3\2\2\2") + buf.write("\u0374\u036f\3\2\2\2\u0374\u0370\3\2\2\2\u0375\u0376\3") + buf.write("\2\2\2\u0376\u0385\5\u0210\u0109\2\u0377\u0378\7\u00d4") + buf.write("\2\2\u0378\u0379\7\u00b5\2\2\u0379\u0385\7\u0267\2\2\u037a") + buf.write("\u037c\7\u00d4\2\2\u037b\u037d\t\2\2\2\u037c\u037b\3\2") + buf.write("\2\2\u037c\u037d\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u0380") + buf.write("\7\u01b1\2\2\u037f\u0381\7\u00da\2\2\u0380\u037f\3\2\2") + buf.write("\2\u0380\u0381\3\2\2\2\u0381\u0382\3\2\2\2\u0382\u0385") + buf.write("\5\u0210\u0109\2\u0383\u0385\5\30\r\2\u0384\u0351\3\2") + buf.write("\2\2\u0384\u035d\3\2\2\2\u0384\u036c\3\2\2\2\u0384\u0374") + buf.write("\3\2\2\2\u0384\u0377\3\2\2\2\u0384\u037a\3\2\2\2\u0384") + buf.write("\u0383\3\2\2\2\u0385\25\3\2\2\2\u0386\u0387\7{\2\2\u0387") + buf.write("\u038f\7\u0082\2\2\u0388\u0390\7\u00e3\2\2\u0389\u038a") + buf.write("\7\u00cb\2\2\u038a\u0390\7\u00c0\2\2\u038b\u038c\7\u00c0") + buf.write("\2\2\u038c\u0390\7\'\2\2\u038d\u038e\7\u00c0\2\2\u038e") + buf.write("\u0390\7\u010c\2\2\u038f\u0388\3\2\2\2\u038f\u0389\3\2") + buf.write("\2\2\u038f\u038b\3\2\2\2\u038f\u038d\3\2\2\2\u0390\u039a") + buf.write("\3\2\2\2\u0391\u0392\7\u00c0\2\2\u0392\u039a\7\u0122\2") + buf.write("\2\u0393\u0394\7\u00c0\2\2\u0394\u039a\7\u01a4\2\2\u0395") + buf.write("\u0397\7\u01a0\2\2\u0396\u0395\3\2\2\2\u0396\u0397\3\2") + buf.write("\2\2\u0397\u0398\3\2\2\2\u0398\u039a\7\u0188\2\2\u0399") + buf.write("\u0386\3\2\2\2\u0399\u0391\3\2\2\2\u0399\u0393\3\2\2\2") + buf.write("\u0399\u0396\3\2\2\2\u039a\27\3\2\2\2\u039b\u039d\7\u0087") + buf.write("\2\2\u039c\u039e\7\u01af\2\2\u039d\u039c\3\2\2\2\u039d") + buf.write("\u039e\3\2\2\2\u039e\u039f\3\2\2\2\u039f\u03a4\5\u0186") + buf.write("\u00c4\2\u03a0\u03a1\7\u0245\2\2\u03a1\u03a3\5\u0186\u00c4") + buf.write("\2\u03a2\u03a0\3\2\2\2\u03a3\u03a6\3\2\2\2\u03a4\u03a2") + buf.write("\3\2\2\2\u03a4\u03a5\3\2\2\2\u03a5\u03ab\3\2\2\2\u03a6") + buf.write("\u03a4\3\2\2\2\u03a7\u03a8\7\u0197\2\2\u03a8\u03a9\5\32") + buf.write("\16\2\u03a9\u03aa\7\u0091\2\2\u03aa\u03ac\3\2\2\2\u03ab") + buf.write("\u03a7\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac\u03ae\3\2\2\2") + buf.write("\u03ad\u03af\7\u009b\2\2\u03ae\u03ad\3\2\2\2\u03ae\u03af") + buf.write("\3\2\2\2\u03af\31\3\2\2\2\u03b0\u03b1\t\4\2\2\u03b1\u03bd") + buf.write("\7\u00e8\2\2\u03b2\u03b3\7\u0144\2\2\u03b3\u03bd\7S\2") + buf.write("\2\u03b4\u03b5\7\u00e8\2\2\u03b5\u03b6\t\5\2\2\u03b6\u03bd") + buf.write("\7S\2\2\u03b7\u03bd\7\u00e8\2\2\u03b8\u03ba\7\5\2\2\u03b9") + buf.write("\u03b8\3\2\2\2\u03b9\u03ba\3\2\2\2\u03ba\u03bb\3\2\2\2") + buf.write("\u03bb\u03bd\7S\2\2\u03bc\u03b0\3\2\2\2\u03bc\u03b2\3") + buf.write("\2\2\2\u03bc\u03b4\3\2\2\2\u03bc\u03b7\3\2\2\2\u03bc\u03b9") + buf.write("\3\2\2\2\u03bd\33\3\2\2\2\u03be\u03da\5\36\20\2\u03bf") + buf.write("\u03c0\7\u0113\2\2\u03c0\u03c2\5\62\32\2\u03c1\u03c3\5") + buf.write(".\30\2\u03c2\u03c1\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03da") + buf.write("\3\2\2\2\u03c4\u03c6\t\6\2\2\u03c5\u03c7\5:\36\2\u03c6") + buf.write("\u03c5\3\2\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c9\3\2\2\2") + buf.write("\u03c8\u03ca\t\7\2\2\u03c9\u03c8\3\2\2\2\u03c9\u03ca\3") + buf.write("\2\2\2\u03ca\u03cb\3\2\2\2\u03cb\u03da\5\u0210\u0109\2") + buf.write("\u03cc\u03cf\7!\2\2\u03cd\u03d0\5\u0210\u0109\2\u03ce") + buf.write("\u03d0\7\u0170\2\2\u03cf\u03cd\3\2\2\2\u03cf\u03ce\3\2") + buf.write("\2\2\u03d0\u03da\3\2\2\2\u03d1\u03d2\7\30\2\2\u03d2\u03da") + buf.write("\5\u0246\u0124\2\u03d3\u03d4\7E\2\2\u03d4\u03da\t\b\2") + buf.write("\2\u03d5\u03da\5&\24\2\u03d6\u03da\5$\23\2\u03d7\u03da") + buf.write("\5 \21\2\u03d8\u03da\5(\25\2\u03d9\u03be\3\2\2\2\u03d9") + buf.write("\u03bf\3\2\2\2\u03d9\u03c4\3\2\2\2\u03d9\u03cc\3\2\2\2") + buf.write("\u03d9\u03d1\3\2\2\2\u03d9\u03d3\3\2\2\2\u03d9\u03d5\3") + buf.write("\2\2\2\u03d9\u03d6\3\2\2\2\u03d9\u03d7\3\2\2\2\u03d9\u03d8") + buf.write("\3\2\2\2\u03da\35\3\2\2\2\u03db\u045a\5\u02b8\u015d\2") + buf.write("\u03dc\u03dd\7\u0083\2\2\u03dd\u045a\5\u0210\u0109\2\u03de") + buf.write("\u03e1\7\u010f\2\2\u03df\u03e2\5\u0210\u0109\2\u03e0\u03e2") + buf.write("\7\u024f\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e0\3\2\2\2\u03e2") + buf.write("\u045a\3\2\2\2\u03e3\u03f0\7\u0172\2\2\u03e4\u03e5\7\u024b") + buf.write("\2\2\u03e5\u03ea\5\66\34\2\u03e6\u03e7\7\u0245\2\2\u03e7") + buf.write("\u03e9\5\66\34\2\u03e8\u03e6\3\2\2\2\u03e9\u03ec\3\2\2") + buf.write("\2\u03ea\u03e8\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ed") + buf.write("\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ed\u03ee\7\u024c\2\2\u03ee") + buf.write("\u03f1\3\2\2\2\u03ef\u03f1\7\u016f\2\2\u03f0\u03e4\3\2") + buf.write("\2\2\u03f0\u03ef\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f3") + buf.write("\3\2\2\2\u03f2\u03f4\5.\30\2\u03f3\u03f2\3\2\2\2\u03f3") + buf.write("\u03f4\3\2\2\2\u03f4\u045a\3\2\2\2\u03f5\u03f7\7\"\2\2") + buf.write("\u03f6\u03f8\7\u016f\2\2\u03f7\u03f6\3\2\2\2\u03f7\u03f8") + buf.write("\3\2\2\2\u03f8\u0402\3\2\2\2\u03f9\u03fa\5\u0210\u0109") + buf.write("\2\u03fa\u03fb\7\u01a3\2\2\u03fb\u03fc\5\u026a\u0136\2") + buf.write("\u03fc\u0403\3\2\2\2\u03fd\u0400\5\u026a\u0136\2\u03fe") + buf.write("\u03ff\7\u01b7\2\2\u03ff\u0401\5\u0210\u0109\2\u0400\u03fe") + buf.write("\3\2\2\2\u0400\u0401\3\2\2\2\u0401\u0403\3\2\2\2\u0402") + buf.write("\u03f9\3\2\2\2\u0402\u03fd\3\2\2\2\u0402\u0403\3\2\2\2") + buf.write("\u0403\u045a\3\2\2\2\u0404\u045a\7\37\2\2\u0405\u0406") + buf.write("\7\u0084\2\2\u0406\u045a\7\u0267\2\2\u0407\u0409\79\2") + buf.write("\2\u0408\u040a\7\u00b4\2\2\u0409\u0408\3\2\2\2\u0409\u040a") + buf.write("\3\2\2\2\u040a\u040d\3\2\2\2\u040b\u040e\5\u0210\u0109") + buf.write("\2\u040c\u040e\7\u0170\2\2\u040d\u040b\3\2\2\2\u040d\u040c") + buf.write("\3\2\2\2\u040e\u045a\3\2\2\2\u040f\u0413\7\u00c7\2\2\u0410") + buf.write("\u0411\7\u024b\2\2\u0411\u0412\7\u016f\2\2\u0412\u0414") + buf.write("\7\u024c\2\2\u0413\u0410\3\2\2\2\u0413\u0414\3\2\2\2\u0414") + buf.write("\u0415\3\2\2\2\u0415\u0417\t\t\2\2\u0416\u0418\7\u015c") + buf.write("\2\2\u0417\u0416\3\2\2\2\u0417\u0418\3\2\2\2\u0418\u0419") + buf.write("\3\2\2\2\u0419\u045a\5\u026a\u0136\2\u041a\u0426\7\u00ce") + buf.write("\2\2\u041b\u041c\5\u0210\u0109\2\u041c\u041d\7\u0253\2") + buf.write("\2\u041d\u041f\3\2\2\2\u041e\u041b\3\2\2\2\u041e\u041f") + buf.write("\3\2\2\2\u041f\u0420\3\2\2\2\u0420\u0427\5\u0210\u0109") + buf.write("\2\u0421\u0422\7\u0148\2\2\u0422\u0427\7\u0126\2\2\u0423") + buf.write("\u0424\7\u00e5\2\2\u0424\u0427\7\u0159\2\2\u0425\u0427") + buf.write("\7\u0170\2\2\u0426\u041e\3\2\2\2\u0426\u0421\3\2\2\2\u0426") + buf.write("\u0423\3\2\2\2\u0426\u0425\3\2\2\2\u0427\u045a\3\2\2\2") + buf.write("\u0428\u0429\7\u00c6\2\2\u0429\u042a\7\u008c\2\2\u042a") + buf.write("\u042c\7\u011a\2\2\u042b\u042d\7\u015c\2\2\u042c\u042b") + buf.write("\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\3\2\2\2\u042e") + buf.write("\u0434\5\u026a\u0136\2\u042f\u0431\7\u01bc\2\2\u0430\u0432") + buf.write("\7\u0098\2\2\u0431\u0430\3\2\2\2\u0431\u0432\3\2\2\2\u0432") + buf.write("\u0433\3\2\2\2\u0433\u0435\7\66\2\2\u0434\u042f\3\2\2") + buf.write("\2\u0434\u0435\3\2\2\2\u0435\u045a\3\2\2\2\u0436\u0437") + buf.write("\7\u00b4\2\2\u0437\u0443\5\u0210\u0109\2\u0438\u0439\7") + buf.write("\u024b\2\2\u0439\u043e\5\u0224\u0113\2\u043a\u043b\7\u0245") + buf.write("\2\2\u043b\u043d\5\u0224\u0113\2\u043c\u043a\3\2\2\2\u043d") + buf.write("\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2\2\2") + buf.write("\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\7") + buf.write("\u024c\2\2\u0442\u0444\3\2\2\2\u0443\u0438\3\2\2\2\u0443") + buf.write("\u0444\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u0446\7\u0176") + buf.write("\2\2\u0446\u0447\5\20\t\2\u0447\u045a\3\2\2\2\u0448\u0449") + buf.write("\7\u00c1\2\2\u0449\u044a\7\u00a9\2\2\u044a\u044b\7\26") + buf.write("\2\2\u044b\u0450\5,\27\2\u044c\u044d\7\u0245\2\2\u044d") + buf.write("\u044f\5,\27\2\u044e\u044c\3\2\2\2\u044f\u0452\3\2\2\2") + buf.write("\u0450\u044e\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u0453\3") + buf.write("\2\2\2\u0452\u0450\3\2\2\2\u0453\u0454\7\u01b1\2\2\u0454") + buf.write("\u0455\5,\27\2\u0455\u045a\3\2\2\2\u0456\u045a\5\u018c") + buf.write("\u00c7\2\u0457\u045a\5\u02b4\u015b\2\u0458\u045a\5\u02b2") + buf.write("\u015a\2\u0459\u03db\3\2\2\2\u0459\u03dc\3\2\2\2\u0459") + buf.write("\u03de\3\2\2\2\u0459\u03e3\3\2\2\2\u0459\u03f5\3\2\2\2") + buf.write("\u0459\u0404\3\2\2\2\u0459\u0405\3\2\2\2\u0459\u0407\3") + buf.write("\2\2\2\u0459\u040f\3\2\2\2\u0459\u041a\3\2\2\2\u0459\u0428") + buf.write("\3\2\2\2\u0459\u0436\3\2\2\2\u0459\u0448\3\2\2\2\u0459") + buf.write("\u0456\3\2\2\2\u0459\u0457\3\2\2\2\u0459\u0458\3\2\2\2") + buf.write("\u045a\37\3\2\2\2\u045b\u046d\7U\2\2\u045c\u045e\7\u0172") + buf.write("\2\2\u045d\u045c\3\2\2\2\u045d\u045e\3\2\2\2\u045e\u0460") + buf.write("\3\2\2\2\u045f\u0461\7\u016f\2\2\u0460\u045f\3\2\2\2\u0460") + buf.write("\u0461\3\2\2\2\u0461\u046e\3\2\2\2\u0462\u0463\7\u024b") + buf.write("\2\2\u0463\u0468\5*\26\2\u0464\u0465\7\u0245\2\2\u0465") + buf.write("\u0467\5*\26\2\u0466\u0464\3\2\2\2\u0467\u046a\3\2\2\2") + buf.write("\u0468\u0466\3\2\2\2\u0468\u0469\3\2\2\2\u0469\u046b\3") + buf.write("\2\2\2\u046a\u0468\3\2\2\2\u046b\u046c\7\u024c\2\2\u046c") + buf.write("\u046e\3\2\2\2\u046d\u045d\3\2\2\2\u046d\u0462\3\2\2\2") + buf.write("\u046e\u046f\3\2\2\2\u046f\u0470\5\"\22\2\u0470!\3\2\2") + buf.write("\2\u0471\u047a\5\20\t\2\u0472\u047a\5$\23\2\u0473\u047a") + buf.write("\5&\24\2\u0474\u0477\7\u0180\2\2\u0475\u0478\5\u01a2\u00d2") + buf.write("\2\u0476\u0478\5\u0196\u00cc\2\u0477\u0475\3\2\2\2\u0477") + buf.write("\u0476\3\2\2\2\u0478\u047a\3\2\2\2\u0479\u0471\3\2\2\2") + buf.write("\u0479\u0472\3\2\2\2\u0479\u0473\3\2\2\2\u0479\u0474\3") + buf.write("\2\2\2\u047a#\3\2\2\2\u047b\u047c\7T\2\2\u047c\u0488\5") + buf.write("\u0210\u0109\2\u047d\u047e\7\u024b\2\2\u047e\u0483\5\u0230") + buf.write("\u0119\2\u047f\u0480\7\u0245\2\2\u0480\u0482\5\u0230\u0119") + buf.write("\2\u0481\u047f\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481") + buf.write("\3\2\2\2\u0483\u0484\3\2\2\2\u0484\u0486\3\2\2\2\u0485") + buf.write("\u0483\3\2\2\2\u0486\u0487\7\u024c\2\2\u0487\u0489\3\2") + buf.write("\2\2\u0488\u047d\3\2\2\2\u0488\u0489\3\2\2\2\u0489%\3") + buf.write("\2\2\2\u048a\u048b\7:\2\2\u048b\u048d\5\u0210\u0109\2") + buf.write("\u048c\u048e\7\u015a\2\2\u048d\u048c\3\2\2\2\u048d\u048e") + buf.write("\3\2\2\2\u048e\u0490\3\2\2\2\u048f\u0491\7w\2\2\u0490") + buf.write("\u048f\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0496\3\2\2\2") + buf.write("\u0492\u0494\7\u0098\2\2\u0493\u0492\3\2\2\2\u0493\u0494") + buf.write("\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0497\7\u00dd\2\2\u0496") + buf.write("\u0493\3\2\2\2\u0496\u0497\3\2\2\2\u0497\u0498\3\2\2\2") + buf.write("\u0498\u049b\7\64\2\2\u0499\u049a\t\n\2\2\u049a\u049c") + buf.write("\7f\2\2\u049b\u0499\3\2\2\2\u049b\u049c\3\2\2\2\u049c") + buf.write("\u049d\3\2\2\2\u049d\u049e\7\u0191\2\2\u049e\u049f\5\u0270") + buf.write("\u0139\2\u049f\'\3\2\2\2\u04a0\u04af\7\u00e9\2\2\u04a1") + buf.write("\u04a2\5\u0210\u0109\2\u04a2\u04a3\7\u0253\2\2\u04a3\u04a5") + buf.write("\3\2\2\2\u04a4\u04a1\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5") + buf.write("\u04a6\3\2\2\2\u04a6\u04b0\5\u0210\u0109\2\u04a7\u04b0") + buf.write("\7\u0170\2\2\u04a8\u04a9\7\u0148\2\2\u04a9\u04b0\7\u0126") + buf.write("\2\2\u04aa\u04ab\7\u0104\2\2\u04ab\u04ac\7{\2\2\u04ac") + buf.write("\u04b0\7\u0082\2\2\u04ad\u04ae\7\u00e5\2\2\u04ae\u04b0") + buf.write("\7\u0159\2\2\u04af\u04a4\3\2\2\2\u04af\u04a7\3\2\2\2\u04af") + buf.write("\u04a8\3\2\2\2\u04af\u04aa\3\2\2\2\u04af\u04ad\3\2\2\2") + buf.write("\u04b0)\3\2\2\2\u04b1\u04b3\t\13\2\2\u04b2\u04b4\58\35") + buf.write("\2\u04b3\u04b2\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4\u04b8") + buf.write("\3\2\2\2\u04b5\u04b6\7\u01d5\2\2\u04b6\u04b8\t\f\2\2\u04b7") + buf.write("\u04b1\3\2\2\2\u04b7\u04b5\3\2\2\2\u04b8+\3\2\2\2\u04b9") + buf.write("\u04bd\5\u0210\u0109\2\u04ba\u04bd\7\u0186\2\2\u04bb\u04bd") + buf.write("\7\u01ac\2\2\u04bc\u04b9\3\2\2\2\u04bc\u04ba\3\2\2\2\u04bc") + buf.write("\u04bb\3\2\2\2\u04bd-\3\2\2\2\u04be\u04c3\5\60\31\2\u04bf") + buf.write("\u04c0\7\u0245\2\2\u04c0\u04c2\5\60\31\2\u04c1\u04bf\3") + buf.write("\2\2\2\u04c2\u04c5\3\2\2\2\u04c3\u04c1\3\2\2\2\u04c3\u04c4") + buf.write("\3\2\2\2\u04c4/\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c6\u04d2") + buf.write("\5\u026a\u0136\2\u04c7\u04c8\7\u024b\2\2\u04c8\u04cd\5") + buf.write("\u0210\u0109\2\u04c9\u04ca\7\u0245\2\2\u04ca\u04cc\5\u0210") + buf.write("\u0109\2\u04cb\u04c9\3\2\2\2\u04cc\u04cf\3\2\2\2\u04cd") + buf.write("\u04cb\3\2\2\2\u04cd\u04ce\3\2\2\2\u04ce\u04d0\3\2\2\2") + buf.write("\u04cf\u04cd\3\2\2\2\u04d0\u04d1\7\u024c\2\2\u04d1\u04d3") + buf.write("\3\2\2\2\u04d2\u04c7\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3") + buf.write("\61\3\2\2\2\u04d4\u04d5\7\u024b\2\2\u04d5\u04da\5\64\33") + buf.write("\2\u04d6\u04d7\7\u0245\2\2\u04d7\u04d9\5\64\33\2\u04d8") + buf.write("\u04d6\3\2\2\2\u04d9\u04dc\3\2\2\2\u04da\u04d8\3\2\2\2") + buf.write("\u04da\u04db\3\2\2\2\u04db\u04dd\3\2\2\2\u04dc\u04da\3") + buf.write("\2\2\2\u04dd\u04de\7\u024c\2\2\u04de\u04ec\3\2\2\2\u04df") + buf.write("\u04e1\7\u0160\2\2\u04e0\u04df\3\2\2\2\u04e0\u04e1\3\2") + buf.write("\2\2\u04e1\u04e3\3\2\2\2\u04e2\u04e4\7\u015f\2\2\u04e3") + buf.write("\u04e2\3\2\2\2\u04e3\u04e4\3\2\2\2\u04e4\u04e6\3\2\2\2") + buf.write("\u04e5\u04e7\7\u016f\2\2\u04e6\u04e5\3\2\2\2\u04e6\u04e7") + buf.write("\3\2\2\2\u04e7\u04e9\3\2\2\2\u04e8\u04ea\7\u0172\2\2\u04e9") + buf.write("\u04e8\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea\u04ec\3\2\2\2") + buf.write("\u04eb\u04d4\3\2\2\2\u04eb\u04e0\3\2\2\2\u04ec\63\3\2") + buf.write("\2\2\u04ed\u04ef\t\r\2\2\u04ee\u04f0\58\35\2\u04ef\u04ee") + buf.write("\3\2\2\2\u04ef\u04f0\3\2\2\2\u04f0\65\3\2\2\2\u04f1\u04f3") + buf.write("\t\16\2\2\u04f2\u04f4\58\35\2\u04f3\u04f2\3\2\2\2\u04f3") + buf.write("\u04f4\3\2\2\2\u04f4\67\3\2\2\2\u04f5\u04f6\t\17\2\2\u04f6") + buf.write("9\3\2\2\2\u04f7\u0509\7\u0097\2\2\u04f8\u0509\7\u00b7") + buf.write("\2\2\u04f9\u0509\7Z\2\2\u04fa\u0509\7\u0080\2\2\u04fb") + buf.write("\u04fd\t\20\2\2\u04fc\u04fb\3\2\2\2\u04fc\u04fd\3\2\2") + buf.write("\2\u04fd\u04fe\3\2\2\2\u04fe\u0509\5\u0150\u00a9\2\u04ff") + buf.write("\u0509\7\u0170\2\2\u0500\u0502\7]\2\2\u0501\u0503\t\21") + buf.write("\2\2\u0502\u0501\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0509") + buf.write("\3\2\2\2\u0504\u0506\7\23\2\2\u0505\u0507\t\21\2\2\u0506") + buf.write("\u0505\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0509\3\2\2\2") + buf.write("\u0508\u04f7\3\2\2\2\u0508\u04f8\3\2\2\2\u0508\u04f9\3") + buf.write("\2\2\2\u0508\u04fa\3\2\2\2\u0508\u04fc\3\2\2\2\u0508\u04ff") + buf.write("\3\2\2\2\u0508\u0500\3\2\2\2\u0508\u0504\3\2\2\2\u0509") + buf.write(";\3\2\2\2\u050a\u050e\5> \2\u050b\u050e\5@!\2\u050c\u050e") + buf.write("\5B\"\2\u050d\u050a\3\2\2\2\u050d\u050b\3\2\2\2\u050d") + buf.write("\u050c\3\2\2\2\u050e=\3\2\2\2\u050f\u0536\7\u0180\2\2") + buf.write("\u0510\u0537\5\u01a0\u00d1\2\u0511\u0537\5\u01a4\u00d3") + buf.write("\2\u0512\u0537\5\u0090I\2\u0513\u0537\5\u009aN\2\u0514") + buf.write("\u0537\5\u0112\u008a\2\u0515\u0537\5\u010e\u0088\2\u0516") + buf.write("\u0537\5\u0136\u009c\2\u0517\u0537\5\u014c\u00a7\2\u0518") + buf.write("\u0537\5\u0156\u00ac\2\u0519\u0537\5\u0196\u00cc\2\u051a") + buf.write("\u0537\5\u009cO\2\u051b\u0537\5\u009eP\2\u051c\u0537\5") + buf.write("\u00a0Q\2\u051d\u0537\5\u00a2R\2\u051e\u0537\5\u00a4S") + buf.write("\2\u051f\u0537\5\u00aaV\2\u0520\u0537\5\u00acW\2\u0521") + buf.write("\u0537\5\u00aeX\2\u0522\u0537\5\u00a6T\2\u0523\u0537\5") + buf.write("\u00b0Y\2\u0524\u0537\5\u00b6\\\2\u0525\u0537\5\u00e0") + buf.write("q\2\u0526\u0537\5\u00e2r\2\u0527\u0537\5\u00e4s\2\u0528") + buf.write("\u0537\5\u00f0y\2\u0529\u0537\5\u00f4{\2\u052a\u0537\5") + buf.write("\u00f6|\2\u052b\u0537\5\u00f8}\2\u052c\u0537\5\u00fc\177") + buf.write("\2\u052d\u0537\5\u0102\u0082\2\u052e\u0537\5\u01a2\u00d2") + buf.write("\2\u052f\u0537\5\u0158\u00ad\2\u0530\u0537\5\u015e\u00b0") + buf.write("\2\u0531\u0537\5\u0164\u00b3\2\u0532\u0537\5\u0168\u00b5") + buf.write("\2\u0533\u0537\5\u0174\u00bb\2\u0534\u0537\5\u017c\u00bf") + buf.write("\2\u0535\u0537\5\u0180\u00c1\2\u0536\u0510\3\2\2\2\u0536") + buf.write("\u0511\3\2\2\2\u0536\u0512\3\2\2\2\u0536\u0513\3\2\2\2") + buf.write("\u0536\u0514\3\2\2\2\u0536\u0515\3\2\2\2\u0536\u0516\3") + buf.write("\2\2\2\u0536\u0517\3\2\2\2\u0536\u0518\3\2\2\2\u0536\u0519") + buf.write("\3\2\2\2\u0536\u051a\3\2\2\2\u0536\u051b\3\2\2\2\u0536") + buf.write("\u051c\3\2\2\2\u0536\u051d\3\2\2\2\u0536\u051e\3\2\2\2") + buf.write("\u0536\u051f\3\2\2\2\u0536\u0520\3\2\2\2\u0536\u0521\3") + buf.write("\2\2\2\u0536\u0522\3\2\2\2\u0536\u0523\3\2\2\2\u0536\u0524") + buf.write("\3\2\2\2\u0536\u0525\3\2\2\2\u0536\u0526\3\2\2\2\u0536") + buf.write("\u0527\3\2\2\2\u0536\u0528\3\2\2\2\u0536\u0529\3\2\2\2") + buf.write("\u0536\u052a\3\2\2\2\u0536\u052b\3\2\2\2\u0536\u052c\3") + buf.write("\2\2\2\u0536\u052d\3\2\2\2\u0536\u052e\3\2\2\2\u0536\u052f") + buf.write("\3\2\2\2\u0536\u0530\3\2\2\2\u0536\u0531\3\2\2\2\u0536") + buf.write("\u0532\3\2\2\2\u0536\u0533\3\2\2\2\u0536\u0534\3\2\2\2") + buf.write("\u0536\u0535\3\2\2\2\u0537\u053e\3\2\2\2\u0538\u053e\5") + buf.write("\u012e\u0098\2\u0539\u053e\5\u0118\u008d\2\u053a\u053e") + buf.write("\5\u0106\u0084\2\u053b\u053e\5D#\2\u053c\u053e\5\u0130") + buf.write("\u0099\2\u053d\u050f\3\2\2\2\u053d\u0538\3\2\2\2\u053d") + buf.write("\u0539\3\2\2\2\u053d\u053a\3\2\2\2\u053d\u053b\3\2\2\2") + buf.write("\u053d\u053c\3\2\2\2\u053e?\3\2\2\2\u053f\u0560\7\f\2") + buf.write("\2\u0540\u0561\5F$\2\u0541\u0561\5P)\2\u0542\u0561\5R") + buf.write("*\2\u0543\u0561\5T+\2\u0544\u0561\5l\67\2\u0545\u0561") + buf.write("\5p9\2\u0546\u0561\5v<\2\u0547\u0561\5x=\2\u0548\u0561") + buf.write("\5z>\2\u0549\u0561\5~@\2\u054a\u0561\5\u0080A\2\u054b") + buf.write("\u0561\5\u0082B\2\u054c\u0561\5\u0086D\2\u054d\u0561\5") + buf.write("\u00b2Z\2\u054e\u0561\5\u00b8]\2\u054f\u0561\5\u00ba^") + buf.write("\2\u0550\u0561\5\u00c0a\2\u0551\u0561\5\u00c4c\2\u0552") + buf.write("\u0561\5\u00caf\2\u0553\u0561\5\u00ccg\2\u0554\u0561\5") + buf.write("\u00d0i\2\u0555\u0561\5H%\2\u0556\u0561\5J&\2\u0557\u0561") + buf.write("\5\u015a\u00ae\2\u0558\u0561\5\u0160\u00b1\2\u0559\u0561") + buf.write("\5\u0188\u00c5\2\u055a\u0561\5\u018a\u00c6\2\u055b\u0561") + buf.write("\5\u016a\u00b6\2\u055c\u0561\5\u0178\u00bd\2\u055d\u0561") + buf.write("\5\u017e\u00c0\2\u055e\u0561\5\u0182\u00c2\2\u055f\u0561") + buf.write("\5\u00c6d\2\u0560\u0540\3\2\2\2\u0560\u0541\3\2\2\2\u0560") + buf.write("\u0542\3\2\2\2\u0560\u0543\3\2\2\2\u0560\u0544\3\2\2\2") + buf.write("\u0560\u0545\3\2\2\2\u0560\u0546\3\2\2\2\u0560\u0547\3") + buf.write("\2\2\2\u0560\u0548\3\2\2\2\u0560\u0549\3\2\2\2\u0560\u054a") + buf.write("\3\2\2\2\u0560\u054b\3\2\2\2\u0560\u054c\3\2\2\2\u0560") + buf.write("\u054d\3\2\2\2\u0560\u054e\3\2\2\2\u0560\u054f\3\2\2\2") + buf.write("\u0560\u0550\3\2\2\2\u0560\u0551\3\2\2\2\u0560\u0552\3") + buf.write("\2\2\2\u0560\u0553\3\2\2\2\u0560\u0554\3\2\2\2\u0560\u0555") + buf.write("\3\2\2\2\u0560\u0556\3\2\2\2\u0560\u0557\3\2\2\2\u0560") + buf.write("\u0558\3\2\2\2\u0560\u0559\3\2\2\2\u0560\u055a\3\2\2\2") + buf.write("\u0560\u055b\3\2\2\2\u0560\u055c\3\2\2\2\u0560\u055d\3") + buf.write("\2\2\2\u0560\u055e\3\2\2\2\u0560\u055f\3\2\2\2\u0561A") + buf.write("\3\2\2\2\u0562\u056e\7I\2\2\u0563\u056f\5\u0204\u0103") + buf.write("\2\u0564\u056f\5\u0206\u0104\2\u0565\u056f\5\u0208\u0105") + buf.write("\2\u0566\u056f\5\u015c\u00af\2\u0567\u056f\5\u0166\u00b4") + buf.write("\2\u0568\u056f\5\u0172\u00ba\2\u0569\u056f\5\u017a\u00be") + buf.write("\2\u056a\u056f\5\u020a\u0106\2\u056b\u056f\5\u00d6l\2") + buf.write("\u056c\u056f\5\u00d8m\2\u056d\u056f\5\u00dan\2\u056e\u0563") + buf.write("\3\2\2\2\u056e\u0564\3\2\2\2\u056e\u0565\3\2\2\2\u056e") + buf.write("\u0566\3\2\2\2\u056e\u0567\3\2\2\2\u056e\u0568\3\2\2\2") + buf.write("\u056e\u0569\3\2\2\2\u056e\u056a\3\2\2\2\u056e\u056b\3") + buf.write("\2\2\2\u056e\u056c\3\2\2\2\u056e\u056d\3\2\2\2\u056fC") + buf.write("\3\2\2\2\u0570\u0571\7m\2\2\u0571\u0572\7\u0192\2\2\u0572") + buf.write("\u0573\7\u00db\2\2\u0573\u057d\5\u0210\u0109\2\u0574\u0575") + buf.write("\7\u019d\2\2\u0575\u0578\7\u01b1\2\2\u0576\u0578\7\u018e") + buf.write("\2\2\u0577\u0574\3\2\2\2\u0577\u0576\3\2\2\2\u0578\u0579") + buf.write("\3\2\2\2\u0579\u057a\7\u024b\2\2\u057a\u057b\5\u02b6\u015c") + buf.write("\2\u057b\u057c\7\u024c\2\2\u057c\u057e\3\2\2\2\u057d\u0577") + buf.write("\3\2\2\2\u057d\u057e\3\2\2\2\u057e\u057f\3\2\2\2\u057f") + buf.write("\u0580\7\u0193\2\2\u0580\u0581\7\u00e4\2\2\u0581\u0582") + buf.write("\5\u0210\u0109\2\u0582\u0583\7\u019a\2\2\u0583\u0585\5") + buf.write("\u0210\u0109\2\u0584\u0586\5\u01bc\u00df\2\u0585\u0584") + buf.write("\3\2\2\2\u0585\u0586\3\2\2\2\u0586E\3\2\2\2\u0587\u0589") + buf.write("\t\22\2\2\u0588\u058a\5\u0140\u00a1\2\u0589\u0588\3\2") + buf.write("\2\2\u0589\u058a\3\2\2\2\u058a\u05a3\3\2\2\2\u058b\u0597") + buf.write("\5h\65\2\u058c\u0594\7\u00ce\2\2\u058d\u058e\5\u0210\u0109") + buf.write("\2\u058e\u058f\7\u0253\2\2\u058f\u0591\3\2\2\2\u0590\u058d") + buf.write("\3\2\2\2\u0590\u0591\3\2\2\2\u0591\u0592\3\2\2\2\u0592") + buf.write("\u0595\5\u0210\u0109\2\u0593\u0595\7\u0170\2\2\u0594\u0590") + buf.write("\3\2\2\2\u0594\u0593\3\2\2\2\u0595\u0597\3\2\2\2\u0596") + buf.write("\u058b\3\2\2\2\u0596\u058c\3\2\2\2\u0597\u0598\3\2\2\2") + buf.write("\u0598\u0596\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059b\3") + buf.write("\2\2\2\u059a\u059c\7\u00d0\2\2\u059b\u059a\3\2\2\2\u059b") + buf.write("\u059c\3\2\2\2\u059c\u05a4\3\2\2\2\u059d\u05a4\5\u01ee") + buf.write("\u00f8\2\u059e\u05a4\5\u01f0\u00f9\2\u059f\u05a0\7A\2") + buf.write("\2\u05a0\u05a1\7\u01a3\2\2\u05a1\u05a2\7V\2\2\u05a2\u05a4") + buf.write("\5\u0210\u0109\2\u05a3\u0596\3\2\2\2\u05a3\u059d\3\2\2") + buf.write("\2\u05a3\u059e\3\2\2\2\u05a3\u059f\3\2\2\2\u05a4G\3\2") + buf.write("\2\2\u05a5\u05a6\7\n\2\2\u05a6\u05a9\5\u0140\u00a1\2\u05a7") + buf.write("\u05aa\5\u01ee\u00f8\2\u05a8\u05aa\5\u01f0\u00f9\2\u05a9") + buf.write("\u05a7\3\2\2\2\u05a9\u05a8\3\2\2\2\u05aaI\3\2\2\2\u05ab") + buf.write("\u05ac\7V\2\2\u05ac\u05ad\5\u0210\u0109\2\u05ad\u05ae") + buf.write("\5L\'\2\u05aeK\3\2\2\2\u05af\u05bb\5\u01f0\u00f9\2\u05b0") + buf.write("\u05b6\7\u0112\2\2\u05b1\u05b4\7\u01b1\2\2\u05b2\u05b5") + buf.write("\5\u0210\u0109\2\u05b3\u05b5\5\u0146\u00a4\2\u05b4\u05b2") + buf.write("\3\2\2\2\u05b4\u05b3\3\2\2\2\u05b5\u05b7\3\2\2\2\u05b6") + buf.write("\u05b1\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05bb\3\2\2\2") + buf.write("\u05b8\u05b9\t\23\2\2\u05b9\u05bb\5N(\2\u05ba\u05af\3") + buf.write("\2\2\2\u05ba\u05b0\3\2\2\2\u05ba\u05b8\3\2\2\2\u05bbM") + buf.write("\3\2\2\2\u05bc\u05bd\7\5\2\2\u05bd\u05be\7\u008e\2\2\u05be") + buf.write("\u0617\5\u026a\u0136\2\u05bf\u05c0\7\n\2\2\u05c0\u0617") + buf.write("\5\u0140\u00a1\2\u05c1\u05c2\7\u017b\2\2\u05c2\u05c3\7") + buf.write("\u024b\2\2\u05c3\u05c4\5\u026a\u0136\2\u05c4\u05c5\7\u0176") + buf.write("\2\2\u05c5\u05c6\5\u026a\u0136\2\u05c6\u05c7\7\u024c\2") + buf.write("\2\u05c7\u0617\3\2\2\2\u05c8\u05c9\7\u015b\2\2\u05c9\u0617") + buf.write("\5\u0210\u0109\2\u05ca\u05cb\7.\2\2\u05cb\u0617\5\u0210") + buf.write("\u0109\2\u05cc\u05cd\7G\2\2\u05cd\u0617\5\u026a\u0136") + buf.write("\2\u05ce\u05cf\7P\2\2\u05cf\u05d0\7\u0106\2\2\u05d0\u0617") + buf.write("\5\u0210\u0109\2\u05d1\u05d2\7\u0192\2\2\u05d2\u05d3\7") + buf.write("\66\2\2\u05d3\u05d4\7\u0121\2\2\u05d4\u0617\5\u0210\u0109") + buf.write("\2\u05d5\u05d6\7\u0192\2\2\u05d6\u05d7\7\u01af\2\2\u05d7") + buf.write("\u0617\5\u026a\u0136\2\u05d8\u05d9\7^\2\2\u05d9\u0617") + buf.write("\5\u0140\u00a1\2\u05da\u05dc\7\u008c\2\2\u05db\u05da\3") + buf.write("\2\2\2\u05db\u05dc\3\2\2\2\u05dc\u05dd\3\2\2\2\u05dd\u05de") + buf.write("\7\u011a\2\2\u05de\u0617\5\u026a\u0136\2\u05df\u05e0\7") + buf.write("\u00a2\2\2\u05e0\u0617\5\u00fe\u0080\2\u05e1\u05e2\7\u00a2") + buf.write("\2\2\u05e2\u05e3\7 \2\2\u05e3\u05e4\5\u026a\u0136\2\u05e4") + buf.write("\u05e5\7\u01b7\2\2\u05e5\u05e6\5\u0210\u0109\2\u05e6\u0617") + buf.write("\3\2\2\2\u05e7\u05e8\7\u00a2\2\2\u05e8\u05e9\7X\2\2\u05e9") + buf.write("\u05ea\5\u026a\u0136\2\u05ea\u05eb\7\u01b7\2\2\u05eb\u05ec") + buf.write("\5\u0210\u0109\2\u05ec\u0617\3\2\2\2\u05ed\u05ef\7\u00b9") + buf.write("\2\2\u05ee\u05ed\3\2\2\2\u05ee\u05ef\3\2\2\2\u05ef\u05f0") + buf.write("\3\2\2\2\u05f0\u05f1\7~\2\2\u05f1\u0617\5\u0210\u0109") + buf.write("\2\u05f2\u05f3\7\u00ba\2\2\u05f3\u0617\5\u0140\u00a1\2") + buf.write("\u05f4\u05f5\7\u00d6\2\2\u05f5\u0617\5\u0140\u00a1\2\u05f6") + buf.write("\u05f7\7\u00db\2\2\u05f7\u0617\5\u0210\u0109\2\u05f8\u05f9") + buf.write("\7\u00e1\2\2\u05f9\u0617\5\u026a\u0136\2\u05fa\u05fb\7") + buf.write("\u00e4\2\2\u05fb\u0617\5\u0210\u0109\2\u05fc\u05fd\7\u01af") + buf.write("\2\2\u05fd\u0617\5\u026a\u0136\2\u05fe\u05ff\7\u0102\2") + buf.write("\2\u05ff\u0600\7\u00de\2\2\u0600\u0601\7(\2\2\u0601\u0617") + buf.write("\5\u026a\u0136\2\u0602\u0603\7\u0102\2\2\u0603\u0604\7") + buf.write("\u00de\2\2\u0604\u0605\7C\2\2\u0605\u0617\5\u026a\u0136") + buf.write("\2\u0606\u0607\7\u0102\2\2\u0607\u0608\7\u00de\2\2\u0608") + buf.write("\u0609\7\u00ac\2\2\u0609\u0617\5\u026a\u0136\2\u060a\u060b") + buf.write("\7\u0102\2\2\u060b\u060c\7\u00de\2\2\u060c\u060d\7\u0100") + buf.write("\2\2\u060d\u0617\5\u026a\u0136\2\u060e\u060f\7\u0105\2") + buf.write("\2\u060f\u0610\7\u0191\2\2\u0610\u0611\5\u0210\u0109\2") + buf.write("\u0611\u0612\7~\2\2\u0612\u0613\5\u0210\u0109\2\u0613") + buf.write("\u0617\3\2\2\2\u0614\u0615\7\u0109\2\2\u0615\u0617\5\u026a") + buf.write("\u0136\2\u0616\u05bc\3\2\2\2\u0616\u05bf\3\2\2\2\u0616") + buf.write("\u05c1\3\2\2\2\u0616\u05c8\3\2\2\2\u0616\u05ca\3\2\2\2") + buf.write("\u0616\u05cc\3\2\2\2\u0616\u05ce\3\2\2\2\u0616\u05d1\3") + buf.write("\2\2\2\u0616\u05d5\3\2\2\2\u0616\u05d8\3\2\2\2\u0616\u05db") + buf.write("\3\2\2\2\u0616\u05df\3\2\2\2\u0616\u05e1\3\2\2\2\u0616") + buf.write("\u05e7\3\2\2\2\u0616\u05ee\3\2\2\2\u0616\u05f2\3\2\2\2") + buf.write("\u0616\u05f4\3\2\2\2\u0616\u05f6\3\2\2\2\u0616\u05f8\3") + buf.write("\2\2\2\u0616\u05fa\3\2\2\2\u0616\u05fc\3\2\2\2\u0616\u05fe") + buf.write("\3\2\2\2\u0616\u0602\3\2\2\2\u0616\u0606\3\2\2\2\u0616") + buf.write("\u060a\3\2\2\2\u0616\u060e\3\2\2\2\u0616\u0614\3\2\2\2") + buf.write("\u0617O\3\2\2\2\u0618\u0619\7\u00db\2\2\u0619\u061a\5") + buf.write("\u0210\u0109\2\u061a\u061b\5\u01ee\u00f8\2\u061bQ\3\2") + buf.write("\2\2\u061c\u061e\7\u00b9\2\2\u061d\u061c\3\2\2\2\u061d") + buf.write("\u061e\3\2\2\2\u061e\u061f\3\2\2\2\u061f\u0620\7~\2\2") + buf.write("\u0620\u0623\5\u0210\u0109\2\u0621\u0624\5\u01ee\u00f8") + buf.write("\2\u0622\u0624\5\u01ec\u00f7\2\u0623\u0621\3\2\2\2\u0623") + buf.write("\u0622\3\2\2\2\u0624S\3\2\2\2\u0625\u0627\7\u0192\2\2") + buf.write("\u0626\u0625\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0628\3") + buf.write("\2\2\2\u0628\u062a\7\u01af\2\2\u0629\u062b\5\u0198\u00cd") + buf.write("\2\u062a\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b\u062d") + buf.write("\3\2\2\2\u062c\u062e\7\u01a4\2\2\u062d\u062c\3\2\2\2\u062d") + buf.write("\u062e\3\2\2\2\u062e\u062f\3\2\2\2\u062f\u0631\5\u026a") + buf.write("\u0136\2\u0630\u0632\7\u024f\2\2\u0631\u0630\3\2\2\2\u0631") + buf.write("\u0632\3\2\2\2\u0632\u0653\3\2\2\2\u0633\u0638\5V,\2\u0634") + buf.write("\u0635\7\u0245\2\2\u0635\u0637\5V,\2\u0636\u0634\3\2\2") + buf.write("\2\u0637\u063a\3\2\2\2\u0638\u0636\3\2\2\2\u0638\u0639") + buf.write("\3\2\2\2\u0639\u0654\3\2\2\2\u063a\u0638\3\2\2\2\u063b") + buf.write("\u063d\7\u00ca\2\2\u063c\u063e\7\u017e\2\2\u063d\u063c") + buf.write("\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u063f\3\2\2\2\u063f") + buf.write("\u0640\5\u0210\u0109\2\u0640\u0641\7\u01b1\2\2\u0641\u0642") + buf.write("\5\u0210\u0109\2\u0642\u0654\3\2\2\2\u0643\u0654\5\u01f0") + buf.write("\u00f9\2\u0644\u0654\5\u01ee\u00f8\2\u0645\u0646\7\u00ca") + buf.write("\2\2\u0646\u0647\7\u017f\2\2\u0647\u0648\5\u0210\u0109") + buf.write("\2\u0648\u0649\7\u01b1\2\2\u0649\u064a\5\u0210\u0109\2") + buf.write("\u064a\u0654\3\2\2\2\u064b\u064c\7\21\2\2\u064c\u064d") + buf.write("\7\u00ae\2\2\u064d\u064e\5\u026a\u0136\2\u064e\u064f\5") + buf.write("\u01aa\u00d6\2\u064f\u0654\3\2\2\2\u0650\u0651\7B\2\2") + buf.write("\u0651\u0652\7\u00ae\2\2\u0652\u0654\5\u026a\u0136\2\u0653") + buf.write("\u0633\3\2\2\2\u0653\u063b\3\2\2\2\u0653\u0643\3\2\2\2") + buf.write("\u0653\u0644\3\2\2\2\u0653\u0645\3\2\2\2\u0653\u064b\3") + buf.write("\2\2\2\u0653\u0650\3\2\2\2\u0654U\3\2\2\2\u0655\u0657") + buf.write("\7\7\2\2\u0656\u0658\7\u017e\2\2\u0657\u0656\3\2\2\2\u0657") + buf.write("\u0658\3\2\2\2\u0658\u065a\3\2\2\2\u0659\u065b\5\u019a") + buf.write("\u00ce\2\u065a\u0659\3\2\2\2\u065a\u065b\3\2\2\2\u065b") + buf.write("\u065c\3\2\2\2\u065c\u06c4\5\u01c8\u00e5\2\u065d\u065f") + buf.write("\7I\2\2\u065e\u0660\7\u017e\2\2\u065f\u065e\3\2\2\2\u065f") + buf.write("\u0660\3\2\2\2\u0660\u0662\3\2\2\2\u0661\u0663\5\u0198") + buf.write("\u00cd\2\u0662\u0661\3\2\2\2\u0662\u0663\3\2\2\2\u0663") + buf.write("\u0664\3\2\2\2\u0664\u0666\5\u0210\u0109\2\u0665\u0667") + buf.write("\5\u01f8\u00fd\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2\2") + buf.write("\2\u0667\u06c4\3\2\2\2\u0668\u066a\7\f\2\2\u0669\u066b") + buf.write("\7\u017e\2\2\u066a\u0669\3\2\2\2\u066a\u066b\3\2\2\2\u066b") + buf.write("\u066c\3\2\2\2\u066c\u066d\5\u0210\u0109\2\u066d\u066e") + buf.write("\5X-\2\u066e\u06c4\3\2\2\2\u066f\u0670\7\7\2\2\u0670\u0673") + buf.write("\5\u01cc\u00e7\2\u0671\u0672\7\u01a0\2\2\u0672\u0674\7") + buf.write("\u0114\2\2\u0673\u0671\3\2\2\2\u0673\u0674\3\2\2\2\u0674") + buf.write("\u06c4\3\2\2\2\u0675\u06c4\5`\61\2\u0676\u06c4\5b\62\2") + buf.write("\u0677\u0678\t\24\2\2\u0678\u067c\7\u0106\2\2\u0679\u067d") + buf.write("\5\u026a\u0136\2\u067a\u067d\7\u0170\2\2\u067b\u067d\7") + buf.write("\u01b6\2\2\u067c\u0679\3\2\2\2\u067c\u067a\3\2\2\2\u067c") + buf.write("\u067b\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u06c4\3\2\2\2") + buf.write("\u067e\u067f\7K\2\2\u067f\u0680\t\25\2\2\u0680\u0681\7") + buf.write("\u0106\2\2\u0681\u06c4\5\u026a\u0136\2\u0682\u0683\t\24") + buf.write("\2\2\u0683\u0684\7\u00d9\2\2\u0684\u06c4\5\u026a\u0136") + buf.write("\2\u0685\u0686\7K\2\2\u0686\u0687\t\25\2\2\u0687\u0688") + buf.write("\7\u00d9\2\2\u0688\u06c4\5\u026a\u0136\2\u0689\u068a\t") + buf.write("\24\2\2\u068a\u068b\7\u0144\2\2\u068b\u068c\7\u0082\2") + buf.write("\2\u068c\u06c4\7\u00e0\2\2\u068d\u068f\7\u0098\2\2\u068e") + buf.write("\u068d\3\2\2\2\u068e\u068f\3\2\2\2\u068f\u0690\3\2\2\2") + buf.write("\u0690\u0691\7\\\2\2\u0691\u0692\7\u0144\2\2\u0692\u0693") + buf.write("\7\u0082\2\2\u0693\u06c4\7\u00e0\2\2\u0694\u0695\7\"\2") + buf.write("\2\u0695\u0696\7\u01a3\2\2\u0696\u06c4\5\u026a\u0136\2") + buf.write("\u0697\u0698\7\u00e6\2\2\u0698\u0699\7\u011f\2\2\u0699") + buf.write("\u06c4\t\26\2\2\u069a\u069b\7\u00e6\2\2\u069b\u069c\7") + buf.write("\u01bc\2\2\u069c\u06c4\7\u00a0\2\2\u069d\u069e\7\u00e6") + buf.write("\2\2\u069e\u06c4\t\27\2\2\u069f\u06a0\7\u00e6\2\2\u06a0") + buf.write("\u06c4\5\u01dc\u00ef\2\u06a1\u06a2\7\u00ce\2\2\u06a2\u06c4") + buf.write("\5\u01d8\u00ed\2\u06a3\u06c4\5\u01bc\u00df\2\u06a4\u06a5") + buf.write("\7s\2\2\u06a5\u06c4\5\u026a\u0136\2\u06a6\u06a7\7\u0098") + buf.write("\2\2\u06a7\u06a8\7s\2\2\u06a8\u06c4\5\u026a\u0136\2\u06a9") + buf.write("\u06aa\7\u009e\2\2\u06aa\u06c4\5\u026a\u0136\2\u06ab\u06ac") + buf.write("\7\u01a0\2\2\u06ac\u06c4\7\u009e\2\2\u06ad\u06c4\5\u01ec") + buf.write("\u00f7\2\u06ae\u06af\7\u00e6\2\2\u06af\u06c4\5\u01e8\u00f5") + buf.write("\2\u06b0\u06b1\7\u00cd\2\2\u06b1\u06b8\7h\2\2\u06b2\u06b9") + buf.write("\7\u0187\2\2\u06b3\u06b9\7\u0160\2\2\u06b4\u06b9\7\u0099") + buf.write("\2\2\u06b5\u06b6\7\u01b7\2\2\u06b6\u06b7\7q\2\2\u06b7") + buf.write("\u06b9\5\u0210\u0109\2\u06b8\u06b2\3\2\2\2\u06b8\u06b3") + buf.write("\3\2\2\2\u06b8\u06b4\3\2\2\2\u06b8\u06b5\3\2\2\2\u06b9") + buf.write("\u06c4\3\2\2\2\u06ba\u06bb\7\f\2\2\u06bb\u06bc\7\u017f") + buf.write("\2\2\u06bc\u06be\5\u0210\u0109\2\u06bd\u06bf\5d\63\2\u06be") + buf.write("\u06bd\3\2\2\2\u06be\u06bf\3\2\2\2\u06bf\u06c1\3\2\2\2") + buf.write("\u06c0\u06c2\5f\64\2\u06c1\u06c0\3\2\2\2\u06c1\u06c2\3") + buf.write("\2\2\2\u06c2\u06c4\3\2\2\2\u06c3\u0655\3\2\2\2\u06c3\u065d") + buf.write("\3\2\2\2\u06c3\u0668\3\2\2\2\u06c3\u066f\3\2\2\2\u06c3") + buf.write("\u0675\3\2\2\2\u06c3\u0676\3\2\2\2\u06c3\u0677\3\2\2\2") + buf.write("\u06c3\u067e\3\2\2\2\u06c3\u0682\3\2\2\2\u06c3\u0685\3") + buf.write("\2\2\2\u06c3\u0689\3\2\2\2\u06c3\u068e\3\2\2\2\u06c3\u0694") + buf.write("\3\2\2\2\u06c3\u0697\3\2\2\2\u06c3\u069a\3\2\2\2\u06c3") + buf.write("\u069d\3\2\2\2\u06c3\u069f\3\2\2\2\u06c3\u06a1\3\2\2\2") + buf.write("\u06c3\u06a3\3\2\2\2\u06c3\u06a4\3\2\2\2\u06c3\u06a6\3") + buf.write("\2\2\2\u06c3\u06a9\3\2\2\2\u06c3\u06ab\3\2\2\2\u06c3\u06ad") + buf.write("\3\2\2\2\u06c3\u06ae\3\2\2\2\u06c3\u06b0\3\2\2\2\u06c3") + buf.write("\u06ba\3\2\2\2\u06c4W\3\2\2\2\u06c5\u06c6\7\u00e6\2\2") + buf.write("\u06c6\u06c8\7\66\2\2\u06c7\u06c5\3\2\2\2\u06c7\u06c8") + buf.write("\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06ca\7\u0109\2\2\u06ca") + buf.write("\u06cc\5\u0224\u0113\2\u06cb\u06cd\5\u01fa\u00fe\2\u06cc") + buf.write("\u06cb\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2") + buf.write("\u06ce\u06cf\7\u01b7\2\2\u06cf\u06d1\5\u0230\u0119\2\u06d0") + buf.write("\u06ce\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06f2\3\2\2\2") + buf.write("\u06d2\u06d3\7\7\2\2\u06d3\u06f2\5Z.\2\u06d4\u06f2\5\u008c") + buf.write("G\2\u06d5\u06f2\5\u008eH\2\u06d6\u06d9\7\u00e6\2\2\u06d7") + buf.write("\u06d9\7I\2\2\u06d8\u06d6\3\2\2\2\u06d8\u06d7\3\2\2\2") + buf.write("\u06d9\u06da\3\2\2\2\u06da\u06db\7\u01a0\2\2\u06db\u06f2") + buf.write("\7\u01a1\2\2\u06dc\u06dd\7I\2\2\u06dd\u06df\7h\2\2\u06de") + buf.write("\u06e0\5\u0198\u00cd\2\u06df\u06de\3\2\2\2\u06df\u06e0") + buf.write("\3\2\2\2\u06e0\u06f2\3\2\2\2\u06e1\u06e2\7\u00e6\2\2\u06e2") + buf.write("\u06f2\5\u01dc\u00ef\2\u06e3\u06e4\7\u00e6\2\2\u06e4\u06e5") + buf.write("\7\u00f2\2\2\u06e5\u06f2\5\u0150\u00a9\2\u06e6\u06e7\7") + buf.write("\u00e6\2\2\u06e7\u06e8\7\u00f5\2\2\u06e8\u06f2\5^\60\2") + buf.write("\u06e9\u06ea\7\u00ce\2\2\u06ea\u06f2\5\u01d8\u00ed\2\u06eb") + buf.write("\u06f2\5\u01bc\u00df\2\u06ec\u06ee\5\\/\2\u06ed\u06ec") + buf.write("\3\2\2\2\u06ee\u06ef\3\2\2\2\u06ef\u06ed\3\2\2\2\u06ef") + buf.write("\u06f0\3\2\2\2\u06f0\u06f2\3\2\2\2\u06f1\u06c7\3\2\2\2") + buf.write("\u06f1\u06d2\3\2\2\2\u06f1\u06d4\3\2\2\2\u06f1\u06d5\3") + buf.write("\2\2\2\u06f1\u06d8\3\2\2\2\u06f1\u06dc\3\2\2\2\u06f1\u06e1") + buf.write("\3\2\2\2\u06f1\u06e3\3\2\2\2\u06f1\u06e6\3\2\2\2\u06f1") + buf.write("\u06e9\3\2\2\2\u06f1\u06eb\3\2\2\2\u06f1\u06ed\3\2\2\2") + buf.write("\u06f2Y\3\2\2\2\u06f3\u06f7\7`\2\2\u06f4\u06f8\7\r\2\2") + buf.write("\u06f5\u06f6\7\26\2\2\u06f6\u06f8\7\u0187\2\2\u06f7\u06f4") + buf.write("\3\2\2\2\u06f7\u06f5\3\2\2\2\u06f8\u06f9\3\2\2\2\u06f9") + buf.write("\u06fa\7\u0176\2\2\u06fa\u0703\7h\2\2\u06fb\u06fd\7\u024b") + buf.write("\2\2\u06fc\u06fe\5\u014e\u00a8\2\u06fd\u06fc\3\2\2\2\u06fe") + buf.write("\u06ff\3\2\2\2\u06ff\u06fd\3\2\2\2\u06ff\u0700\3\2\2\2") + buf.write("\u0700\u0701\3\2\2\2\u0701\u0702\7\u024c\2\2\u0702\u0704") + buf.write("\3\2\2\2\u0703\u06fb\3\2\2\2\u0703\u0704\3\2\2\2\u0704") + buf.write("[\3\2\2\2\u0705\u0706\7\u00e6\2\2\u0706\u070a\7`\2\2\u0707") + buf.write("\u070b\7\r\2\2\u0708\u0709\7\26\2\2\u0709\u070b\7\u0187") + buf.write("\2\2\u070a\u0707\3\2\2\2\u070a\u0708\3\2\2\2\u070b\u0716") + buf.write("\3\2\2\2\u070c\u070d\7\u00e6\2\2\u070d\u0716\5\u014e\u00a8") + buf.write("\2\u070e\u0713\7\u00cf\2\2\u070f\u0711\7\u01bc\2\2\u0710") + buf.write("\u070f\3\2\2\2\u0710\u0711\3\2\2\2\u0711\u0712\3\2\2\2") + buf.write("\u0712\u0714\7\u0262\2\2\u0713\u0710\3\2\2\2\u0713\u0714") + buf.write("\3\2\2\2\u0714\u0716\3\2\2\2\u0715\u0705\3\2\2\2\u0715") + buf.write("\u070c\3\2\2\2\u0715\u070e\3\2\2\2\u0716]\3\2\2\2\u0717") + buf.write("\u0718\t\30\2\2\u0718_\3\2\2\2\u0719\u071a\7\u0115\2\2") + buf.write("\u071a\u071b\7\u017f\2\2\u071b\u071c\5\u026a\u0136\2\u071c") + buf.write("a\3\2\2\2\u071d\u071e\7I\2\2\u071e\u0720\7\u017f\2\2\u071f") + buf.write("\u0721\5\u0198\u00cd\2\u0720\u071f\3\2\2\2\u0720\u0721") + buf.write("\3\2\2\2\u0721\u0722\3\2\2\2\u0722\u0724\5\u0210\u0109") + buf.write("\2\u0723\u0725\5\u01f8\u00fd\2\u0724\u0723\3\2\2\2\u0724") + buf.write("\u0725\3\2\2\2\u0725c\3\2\2\2\u0726\u0728\7\u01a0\2\2") + buf.write("\u0727\u0726\3\2\2\2\u0727\u0728\3\2\2\2\u0728\u0729\3") + buf.write("\2\2\2\u0729\u072a\7\u0188\2\2\u072ae\3\2\2\2\u072b\u072c") + buf.write("\7\u0198\2\2\u072c\u072d\t\31\2\2\u072dg\3\2\2\2\u072e") + buf.write("\u0732\7\31\2\2\u072f\u0730\7\u00d1\2\2\u0730\u0732\7") + buf.write("\u01a1\2\2\u0731\u072e\3\2\2\2\u0731\u072f\3\2\2\2\u0732") + buf.write("\u0733\3\2\2\2\u0733\u0734\7\u01a3\2\2\u0734\u0735\7\u01a1") + buf.write("\2\2\u0735\u0767\7v\2\2\u0736\u0737\7\u0105\2\2\u0737") + buf.write("\u073c\5\u013a\u009e\2\u0738\u0739\7\u0245\2\2\u0739\u073b") + buf.write("\5\u013a\u009e\2\u073a\u0738\3\2\2\2\u073b\u073e\3\2\2") + buf.write("\2\u073c\u073a\3\2\2\2\u073c\u073d\3\2\2\2\u073d\u0767") + buf.write("\3\2\2\2\u073e\u073c\3\2\2\2\u073f\u0767\7\u00f7\2\2\u0740") + buf.write("\u0767\7k\2\2\u0741\u0767\7\u011c\2\2\u0742\u0767\7\u00ee") + buf.write("\2\2\u0743\u0745\7\u01a0\2\2\u0744\u0743\3\2\2\2\u0744") + buf.write("\u0745\3\2\2\2\u0745\u0746\3\2\2\2\u0746\u0767\7\u0081") + buf.write("\2\2\u0747\u0749\7W\2\2\u0748\u0747\3\2\2\2\u0748\u0749") + buf.write("\3\2\2\2\u0749\u074a\3\2\2\2\u074a\u074b\7\u00e0\2\2\u074b") + buf.write("\u0767\t\32\2\2\u074c\u074d\7\u00ab\2\2\u074d\u0767\t") + buf.write("\33\2\2\u074e\u074f\7\60\2\2\u074f\u0767\5\u023e\u0120") + buf.write("\2\u0750\u0751\7\u00d8\2\2\u0751\u0767\5\u023e\u0120\2") + buf.write("\u0752\u0753\7\u00fa\2\2\u0753\u0767\5\u026a\u0136\2\u0754") + buf.write("\u0758\7\u00e6\2\2\u0755\u0756\5\u0210\u0109\2\u0756\u0757") + buf.write("\7\u0253\2\2\u0757\u0759\3\2\2\2\u0758\u0755\3\2\2\2\u0758") + buf.write("\u0759\3\2\2\2\u0759\u075a\3\2\2\2\u075a\u075f\5\u0210") + buf.write("\u0109\2\u075b\u075c\t\34\2\2\u075c\u0760\5\u010c\u0087") + buf.write("\2\u075d\u075e\7\u0193\2\2\u075e\u0760\7\63\2\2\u075f") + buf.write("\u075b\3\2\2\2\u075f\u075d\3\2\2\2\u0760\u0767\3\2\2\2") + buf.write("\u0761\u0762\7~\2\2\u0762\u0767\5\u0210\u0109\2\u0763") + buf.write("\u0767\7\u01bb\2\2\u0764\u0765\7\u0176\2\2\u0765\u0767") + buf.write("\5j\66\2\u0766\u0731\3\2\2\2\u0766\u0736\3\2\2\2\u0766") + buf.write("\u073f\3\2\2\2\u0766\u0740\3\2\2\2\u0766\u0741\3\2\2\2") + buf.write("\u0766\u0742\3\2\2\2\u0766\u0744\3\2\2\2\u0766\u0748\3") + buf.write("\2\2\2\u0766\u074c\3\2\2\2\u0766\u074e\3\2\2\2\u0766\u0750") + buf.write("\3\2\2\2\u0766\u0752\3\2\2\2\u0766\u0754\3\2\2\2\u0766") + buf.write("\u0761\3\2\2\2\u0766\u0763\3\2\2\2\u0766\u0764\3\2\2\2") + buf.write("\u0767i\3\2\2\2\u0768\u076b\5\u0146\u00a4\2\u0769\u076a") + buf.write("\7\u0245\2\2\u076a\u076c\5\u0146\u00a4\2\u076b\u0769\3") + buf.write("\2\2\2\u076b\u076c\3\2\2\2\u076ck\3\2\2\2\u076d\u076f") + buf.write("\7q\2\2\u076e\u0770\5\u0198\u00cd\2\u076f\u076e\3\2\2") + buf.write("\2\u076f\u0770\3\2\2\2\u0770\u0771\3\2\2\2\u0771\u0772") + buf.write("\5\u026a\u0136\2\u0772\u0773\5n8\2\u0773\u0785\3\2\2\2") + buf.write("\u0774\u0775\7q\2\2\u0775\u0776\7\u0170\2\2\u0776\u0777") + buf.write("\7\u0197\2\2\u0777\u0778\7\u00fe\2\2\u0778\u077c\5\u0210") + buf.write("\u0109\2\u0779\u077a\7\u00a9\2\2\u077a\u077b\7\26\2\2") + buf.write("\u077b\u077d\5\u02b6\u015c\2\u077c\u0779\3\2\2\2\u077c") + buf.write("\u077d\3\2\2\2\u077d\u077e\3\2\2\2\u077e\u077f\7\u00e6") + buf.write("\2\2\u077f\u0780\7\u00fe\2\2\u0780\u0782\5\u0210\u0109") + buf.write("\2\u0781\u0783\7\u009b\2\2\u0782\u0781\3\2\2\2\u0782\u0783") + buf.write("\3\2\2\2\u0783\u0785\3\2\2\2\u0784\u076d\3\2\2\2\u0784") + buf.write("\u0774\3\2\2\2\u0785m\3\2\2\2\u0786\u07ae\5\u01ee\u00f8") + buf.write("\2\u0787\u0788\7\21\2\2\u0788\u0789\7\u00ae\2\2\u0789") + buf.write("\u07ae\5\u026a\u0136\2\u078a\u078b\7A\2\2\u078b\u078c") + buf.write("\7\u01a3\2\2\u078c\u078d\7V\2\2\u078d\u07ae\5\u026a\u0136") + buf.write("\2\u078e\u0790\7\f\2\2\u078f\u0791\7\u017e\2\2\u0790\u078f") + buf.write("\3\2\2\2\u0790\u0791\3\2\2\2\u0791\u0793\3\2\2\2\u0792") + buf.write("\u0794\5\u0154\u00ab\2\u0793\u0792\3\2\2\2\u0793\u0794") + buf.write("\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\7\u0262\2\2\u0796") + buf.write("\u0797\7\u00e6\2\2\u0797\u0798\7\u00f2\2\2\u0798\u07ae") + buf.write("\5\u0150\u00a9\2\u0799\u079a\7\u00ce\2\2\u079a\u079b\7") + buf.write("\u024b\2\2\u079b\u079c\5\u02b6\u015c\2\u079c\u079d\7\u024c") + buf.write("\2\2\u079d\u07ae\3\2\2\2\u079e\u079f\7\u00e6\2\2\u079f") + buf.write("\u07a0\7\u00fe\2\2\u07a0\u07ae\5\u0210\u0109\2\u07a1\u07a2") + buf.write("\7\u00e6\2\2\u07a2\u07a3\7\u024b\2\2\u07a3\u07a8\5\u00a8") + buf.write("U\2\u07a4\u07a5\7\u0245\2\2\u07a5\u07a7\5\u00a8U\2\u07a6") + buf.write("\u07a4\3\2\2\2\u07a7\u07aa\3\2\2\2\u07a8\u07a6\3\2\2\2") + buf.write("\u07a8\u07a9\3\2\2\2\u07a9\u07ab\3\2\2\2\u07aa\u07a8\3") + buf.write("\2\2\2\u07ab\u07ac\7\u024c\2\2\u07ac\u07ae\3\2\2\2\u07ad") + buf.write("\u0786\3\2\2\2\u07ad\u0787\3\2\2\2\u07ad\u078a\3\2\2\2") + buf.write("\u07ad\u078e\3\2\2\2\u07ad\u0799\3\2\2\2\u07ad\u079e\3") + buf.write("\2\2\2\u07ad\u07a1\3\2\2\2\u07aeo\3\2\2\2\u07af\u07b0") + buf.write("\7\u0187\2\2\u07b0\u07b4\7\u00b8\2\2\u07b1\u07b2\7\u0191") + buf.write("\2\2\u07b2\u07b3\t\35\2\2\u07b3\u07b5\5\u02b6\u015c\2") + buf.write("\u07b4\u07b1\3\2\2\2\u07b4\u07b5\3\2\2\2\u07b5\u07b9\3") + buf.write("\2\2\2\u07b6\u07b7\7\u0197\2\2\u07b7\u07b8\7\u00db\2\2") + buf.write("\u07b8\u07ba\5\u02b6\u015c\2\u07b9\u07b6\3\2\2\2\u07b9") + buf.write("\u07ba\3\2\2\2\u07ba\u07bb\3\2\2\2\u07bb\u07bc\5r:\2\u07bc") + buf.write("q\3\2\2\2\u07bd\u07c3\7\u0194\2\2\u07be\u07c0\7\u00d2") + buf.write("\2\2\u07bf\u07c1\5t;\2\u07c0\u07bf\3\2\2\2\u07c0\u07c1") + buf.write("\3\2\2\2\u07c1\u07c3\3\2\2\2\u07c2\u07bd\3\2\2\2\u07c2") + buf.write("\u07be\3\2\2\2\u07c3\u07fb\3\2\2\2\u07c4\u07c9\5\u01f2") + buf.write("\u00fa\2\u07c5\u07c6\7\u0245\2\2\u07c6\u07c8\5\u01f2\u00fa") + buf.write("\2\u07c7\u07c5\3\2\2\2\u07c8\u07cb\3\2\2\2\u07c9\u07c7") + buf.write("\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca\u07cc\3\2\2\2\u07cb") + buf.write("\u07c9\3\2\2\2\u07cc\u07cd\7\u01a3\2\2\u07cd\u07ce\7\u00fd") + buf.write("\2\2\u07ce\u07fc\3\2\2\2\u07cf\u07d4\5\u01f4\u00fb\2\u07d0") + buf.write("\u07d1\7\u0245\2\2\u07d1\u07d3\5\u01f4\u00fb\2\u07d2\u07d0") + buf.write("\3\2\2\2\u07d3\u07d6\3\2\2\2\u07d4\u07d2\3\2\2\2\u07d4") + buf.write("\u07d5\3\2\2\2\u07d5\u07dc\3\2\2\2\u07d6\u07d4\3\2\2\2") + buf.write("\u07d7\u07d9\7\u0170\2\2\u07d8\u07da\7\u00b8\2\2\u07d9") + buf.write("\u07d8\3\2\2\2\u07d9\u07da\3\2\2\2\u07da\u07dc\3\2\2\2") + buf.write("\u07db\u07cf\3\2\2\2\u07db\u07d7\3\2\2\2\u07dc\u07dd\3") + buf.write("\2\2\2\u07dd\u07de\7\u01a3\2\2\u07de\u07fc\7\u00e2\2\2") + buf.write("\u07df\u07e5\7T\2\2\u07e0\u07e2\7\u0170\2\2\u07e1\u07e3") + buf.write("\7\u00b8\2\2\u07e2\u07e1\3\2\2\2\u07e2\u07e3\3\2\2\2\u07e3") + buf.write("\u07e5\3\2\2\2\u07e4\u07df\3\2\2\2\u07e4\u07e0\3\2\2\2") + buf.write("\u07e5\u07e6\3\2\2\2\u07e6\u07e7\7\u01a3\2\2\u07e7\u07fc") + buf.write("\7_\2\2\u07e8\u07ef\7\u021d\2\2\u07e9\u07ef\7\u0180\2") + buf.write("\2\u07ea\u07ec\7\u0170\2\2\u07eb\u07ed\7\u00b8\2\2\u07ec") + buf.write("\u07eb\3\2\2\2\u07ec\u07ed\3\2\2\2\u07ed\u07ef\3\2\2\2") + buf.write("\u07ee\u07e8\3\2\2\2\u07ee\u07e9\3\2\2\2\u07ee\u07ea\3") + buf.write("\2\2\2\u07ef\u07f0\3\2\2\2\u07f0\u07f1\7\u01a3\2\2\u07f1") + buf.write("\u07fc\7\u00dc\2\2\u07f2\u07f8\7\u021d\2\2\u07f3\u07f5") + buf.write("\7\u0170\2\2\u07f4\u07f6\7\u00b8\2\2\u07f5\u07f4\3\2\2") + buf.write("\2\u07f5\u07f6\3\2\2\2\u07f6\u07f8\3\2\2\2\u07f7\u07f2") + buf.write("\3\2\2\2\u07f7\u07f3\3\2\2\2\u07f8\u07f9\3\2\2\2\u07f9") + buf.write("\u07fa\7\u01a3\2\2\u07fa\u07fc\7\u010a\2\2\u07fb\u07c4") + buf.write("\3\2\2\2\u07fb\u07db\3\2\2\2\u07fb\u07e4\3\2\2\2\u07fb") + buf.write("\u07ee\3\2\2\2\u07fb\u07f7\3\2\2\2\u07fc\u07ff\3\2\2\2") + buf.write("\u07fd\u0800\5\u0126\u0094\2\u07fe\u0800\5\u0128\u0095") + buf.write("\2\u07ff\u07fd\3\2\2\2\u07ff\u07fe\3\2\2\2\u0800s\3\2") + buf.write("\2\2\u0801\u0802\7\u0194\2\2\u0802\u0803\7\u00a3\2\2\u0803") + buf.write("\u0804\7\u0191\2\2\u0804u\3\2\2\2\u0805\u0807\7\u00e1") + buf.write("\2\2\u0806\u0808\5\u0198\u00cd\2\u0807\u0806\3\2\2\2\u0807") + buf.write("\u0808\3\2\2\2\u0808\u0809\3\2\2\2\u0809\u0819\5\u026a") + buf.write("\u0136\2\u080a\u0813\5\u014e\u00a8\2\u080b\u0810\7\u00cf") + buf.write("\2\2\u080c\u080e\7\u01bc\2\2\u080d\u080c\3\2\2\2\u080d") + buf.write("\u080e\3\2\2\2\u080e\u080f\3\2\2\2\u080f\u0811\5\u0150") + buf.write("\u00a9\2\u0810\u080d\3\2\2\2\u0810\u0811\3\2\2\2\u0811") + buf.write("\u0813\3\2\2\2\u0812\u080a\3\2\2\2\u0812\u080b\3\2\2\2") + buf.write("\u0813\u0816\3\2\2\2\u0814\u0812\3\2\2\2\u0814\u0815\3") + buf.write("\2\2\2\u0815\u081a\3\2\2\2\u0816\u0814\3\2\2\2\u0817\u081a") + buf.write("\5\u01f0\u00f9\2\u0818\u081a\5\u01ee\u00f8\2\u0819\u0814") + buf.write("\3\2\2\2\u0819\u0817\3\2\2\2\u0819\u0818\3\2\2\2\u081a") + buf.write("w\3\2\2\2\u081b\u081d\7\u008c\2\2\u081c\u081b\3\2\2\2") + buf.write("\u081c\u081d\3\2\2\2\u081d\u081e\3\2\2\2\u081e\u0820\7") + buf.write("\u011a\2\2\u081f\u0821\5\u0198\u00cd\2\u0820\u081f\3\2") + buf.write("\2\2\u0820\u0821\3\2\2\2\u0821\u0822\3\2\2\2\u0822\u0832") + buf.write("\5\u026a\u0136\2\u0823\u0825\7\f\2\2\u0824\u0826\7\u017e") + buf.write("\2\2\u0825\u0824\3\2\2\2\u0825\u0826\3\2\2\2\u0826\u0827") + buf.write("\3\2\2\2\u0827\u082a\5\u026a\u0136\2\u0828\u082b\5\u008c") + buf.write("G\2\u0829\u082b\5\u008eH\2\u082a\u0828\3\2\2\2\u082a\u0829") + buf.write("\3\2\2\2\u082b\u0833\3\2\2\2\u082c\u0833\5\u01f0\u00f9") + buf.write("\2\u082d\u0833\5\u01ee\u00f8\2\u082e\u082f\7\u00e6\2\2") + buf.write("\u082f\u0833\5\u01dc\u00ef\2\u0830\u0831\7\u00ce\2\2\u0831") + buf.write("\u0833\5\u01d8\u00ed\2\u0832\u0823\3\2\2\2\u0832\u082c") + buf.write("\3\2\2\2\u0832\u082d\3\2\2\2\u0832\u082e\3\2\2\2\u0832") + buf.write("\u0830\3\2\2\2\u0833y\3\2\2\2\u0834\u0835\7P\2\2\u0835") + buf.write("\u0836\7\u0106\2\2\u0836\u0837\5\u0210\u0109\2\u0837\u0838") + buf.write("\5|?\2\u0838{\3\2\2\2\u0839\u0841\7D\2\2\u083a\u083c\7") + buf.write("K\2\2\u083b\u083d\t\25\2\2\u083c\u083b\3\2\2\2\u083c\u083d") + buf.write("\3\2\2\2\u083d\u0841\3\2\2\2\u083e\u0841\5\u01ec\u00f7") + buf.write("\2\u083f\u0841\5\u01ee\u00f8\2\u0840\u0839\3\2\2\2\u0840") + buf.write("\u083a\3\2\2\2\u0840\u083e\3\2\2\2\u0840\u083f\3\2\2\2") + buf.write("\u0841}\3\2\2\2\u0842\u0843\7\u0109\2\2\u0843\u0866\5") + buf.write("\u026a\u0136\2\u0844\u0867\5\u01f0\u00f9\2\u0845\u0867") + buf.write("\5\u01ee\u00f8\2\u0846\u0847\7\7\2\2\u0847\u0849\7\u0117") + buf.write("\2\2\u0848\u084a\5\u019a\u00ce\2\u0849\u0848\3\2\2\2\u0849") + buf.write("\u084a\3\2\2\2\u084a\u084b\3\2\2\2\u084b\u084e\5\u0146") + buf.write("\u00a4\2\u084c\u084d\t\36\2\2\u084d\u084f\5\u0146\u00a4") + buf.write("\2\u084e\u084c\3\2\2\2\u084e\u084f\3\2\2\2\u084f\u0867") + buf.write("\3\2\2\2\u0850\u0851\7\u00ca\2\2\u0851\u0852\7\22\2\2") + buf.write("\u0852\u0853\5\u0210\u0109\2\u0853\u0854\7\u01b1\2\2\u0854") + buf.write("\u0856\5\u0210\u0109\2\u0855\u0857\5\u01f8\u00fd\2\u0856") + buf.write("\u0855\3\2\2\2\u0856\u0857\3\2\2\2\u0857\u0867\3\2\2\2") + buf.write("\u0858\u0859\7\u00ca\2\2\u0859\u085a\7\u0117\2\2\u085a") + buf.write("\u085b\5\u0146\u00a4\2\u085b\u085c\7\u01b1\2\2\u085c\u085d") + buf.write("\5\u0146\u00a4\2\u085d\u0867\3\2\2\2\u085e\u0863\5\u008a") + buf.write("F\2\u085f\u0860\7\u0245\2\2\u0860\u0862\5\u008aF\2\u0861") + buf.write("\u085f\3\2\2\2\u0862\u0865\3\2\2\2\u0863\u0861\3\2\2\2") + buf.write("\u0863\u0864\3\2\2\2\u0864\u0867\3\2\2\2\u0865\u0863\3") + buf.write("\2\2\2\u0866\u0844\3\2\2\2\u0866\u0845\3\2\2\2\u0866\u0846") + buf.write("\3\2\2\2\u0866\u0850\3\2\2\2\u0866\u0858\3\2\2\2\u0866") + buf.write("\u085e\3\2\2\2\u0867\177\3\2\2\2\u0868\u0869\7G\2\2\u0869") + buf.write("\u087f\5\u026a\u0136\2\u086a\u0880\5\u008cG\2\u086b\u0880") + buf.write("\5\u008eH\2\u086c\u086d\t\37\2\2\u086d\u086e\7\u01a0\2") + buf.write("\2\u086e\u0880\7\u01a1\2\2\u086f\u0870\7\7\2\2\u0870\u0873") + buf.write("\5\u00dep\2\u0871\u0872\7\u01a0\2\2\u0872\u0874\7\u0114") + buf.write("\2\2\u0873\u0871\3\2\2\2\u0873\u0874\3\2\2\2\u0874\u0880") + buf.write("\3\2\2\2\u0875\u0880\5b\62\2\u0876\u0877\7\u00ca\2\2\u0877") + buf.write("\u0878\7\u017f\2\2\u0878\u0879\5\u026a\u0136\2\u0879\u087a") + buf.write("\7\u01b1\2\2\u087a\u087b\5\u026a\u0136\2\u087b\u0880\3") + buf.write("\2\2\2\u087c\u0880\5`\61\2\u087d\u0880\5\u01ee\u00f8\2") + buf.write("\u087e\u0880\5\u01f0\u00f9\2\u087f\u086a\3\2\2\2\u087f") + buf.write("\u086b\3\2\2\2\u087f\u086c\3\2\2\2\u087f\u086f\3\2\2\2") + buf.write("\u087f\u0875\3\2\2\2\u087f\u0876\3\2\2\2\u087f\u087c\3") + buf.write("\2\2\2\u087f\u087d\3\2\2\2\u087f\u087e\3\2\2\2\u0880\u0081") + buf.write("\3\2\2\2\u0881\u0882\7\u00e4\2\2\u0882\u0883\5\u0210\u0109") + buf.write("\2\u0883\u0884\5\u0084C\2\u0884\u0083\3\2\2\2\u0885\u0886") + buf.write("\7\u0119\2\2\u0886\u0888\5\u0146\u00a4\2\u0887\u0885\3") + buf.write("\2\2\2\u0887\u0888\3\2\2\2\u0888\u0889\3\2\2\2\u0889\u088f") + buf.write("\5\u01bc\u00df\2\u088a\u088b\7\u0119\2\2\u088b\u088f\5") + buf.write("\u0146\u00a4\2\u088c\u088f\5\u01ec\u00f7\2\u088d\u088f") + buf.write("\5\u01ee\u00f8\2\u088e\u0887\3\2\2\2\u088e\u088a\3\2\2") + buf.write("\2\u088e\u088c\3\2\2\2\u088e\u088d\3\2\2\2\u088f\u0085") + buf.write("\3\2\2\2\u0890\u0891\7\u0102\2\2\u0891\u08a0\7\u00de\2") + buf.write("\2\u0892\u0893\t \2\2\u0893\u0896\5\u026a\u0136\2\u0894") + buf.write("\u0897\5\u01ee\u00f8\2\u0895\u0897\5\u01f0\u00f9\2\u0896") + buf.write("\u0894\3\2\2\2\u0896\u0895\3\2\2\2\u0897\u08a1\3\2\2\2") + buf.write("\u0898\u0899\7C\2\2\u0899\u089a\5\u026a\u0136\2\u089a") + buf.write("\u089b\5\u01dc\u00ef\2\u089b\u08a1\3\2\2\2\u089c\u089d") + buf.write("\7(\2\2\u089d\u089e\5\u026a\u0136\2\u089e\u089f\5\u0088") + buf.write("E\2\u089f\u08a1\3\2\2\2\u08a0\u0892\3\2\2\2\u08a0\u0898") + buf.write("\3\2\2\2\u08a0\u089c\3\2\2\2\u08a1\u0087\3\2\2\2\u08a2") + buf.write("\u08a3\t!\2\2\u08a3\u08a4\7\u008a\2\2\u08a4\u08a5\7\u0191") + buf.write("\2\2\u08a5\u08a6\5\u02b6\u015c\2\u08a6\u08a7\7\u01bc\2") + buf.write("\2\u08a7\u08ac\5\u026a\u0136\2\u08a8\u08a9\7\u0245\2\2") + buf.write("\u08a9\u08ab\5\u026a\u0136\2\u08aa\u08a8\3\2\2\2\u08ab") + buf.write("\u08ae\3\2\2\2\u08ac\u08aa\3\2\2\2\u08ac\u08ad\3\2\2\2") + buf.write("\u08ad\u08c3\3\2\2\2\u08ae\u08ac\3\2\2\2\u08af\u08b0\7") + buf.write("\f\2\2\u08b0\u08b3\7\u008a\2\2\u08b1\u08b2\7\u0191\2\2") + buf.write("\u08b2\u08b4\5\u02b6\u015c\2\u08b3\u08b1\3\2\2\2\u08b3") + buf.write("\u08b4\3\2\2\2\u08b4\u08b5\3\2\2\2\u08b5\u08b6\7\u00cc") + buf.write("\2\2\u08b6\u08b7\5\u026a\u0136\2\u08b7\u08b8\7\u01bc\2") + buf.write("\2\u08b8\u08b9\5\u026a\u0136\2\u08b9\u08c3\3\2\2\2\u08ba") + buf.write("\u08bb\7I\2\2\u08bb\u08be\7\u008a\2\2\u08bc\u08bd\7i\2") + buf.write("\2\u08bd\u08bf\7\u0130\2\2\u08be\u08bc\3\2\2\2\u08be\u08bf") + buf.write("\3\2\2\2\u08bf\u08c0\3\2\2\2\u08c0\u08c1\7\u0191\2\2\u08c1") + buf.write("\u08c3\5\u02b6\u015c\2\u08c2\u08a2\3\2\2\2\u08c2\u08af") + buf.write("\3\2\2\2\u08c2\u08ba\3\2\2\2\u08c3\u0089\3\2\2\2\u08c4") + buf.write("\u08c5\7\7\2\2\u08c5\u08c6\7\22\2\2\u08c6\u08c7\5\u0210") + buf.write("\u0109\2\u08c7\u08c9\5\u0224\u0113\2\u08c8\u08ca\5\u01fa") + buf.write("\u00fe\2\u08c9\u08c8\3\2\2\2\u08c9\u08ca\3\2\2\2\u08ca") + buf.write("\u08cc\3\2\2\2\u08cb\u08cd\5\u01f8\u00fd\2\u08cc\u08cb") + buf.write("\3\2\2\2\u08cc\u08cd\3\2\2\2\u08cd\u08e7\3\2\2\2\u08ce") + buf.write("\u08cf\7I\2\2\u08cf\u08d1\7\22\2\2\u08d0\u08d2\5\u0198") + buf.write("\u00cd\2\u08d1\u08d0\3\2\2\2\u08d1\u08d2\3\2\2\2\u08d2") + buf.write("\u08d3\3\2\2\2\u08d3\u08d5\5\u0210\u0109\2\u08d4\u08d6") + buf.write("\5\u01f8\u00fd\2\u08d5\u08d4\3\2\2\2\u08d5\u08d6\3\2\2") + buf.write("\2\u08d6\u08e7\3\2\2\2\u08d7\u08d8\7\f\2\2\u08d8\u08d9") + buf.write("\7\22\2\2\u08d9\u08dc\5\u0210\u0109\2\u08da\u08db\7\u00e6") + buf.write("\2\2\u08db\u08dd\7\66\2\2\u08dc\u08da\3\2\2\2\u08dc\u08dd") + buf.write("\3\2\2\2\u08dd\u08de\3\2\2\2\u08de\u08df\7\u0109\2\2\u08df") + buf.write("\u08e1\5\u0224\u0113\2\u08e0\u08e2\5\u01fa\u00fe\2\u08e1") + buf.write("\u08e0\3\2\2\2\u08e1\u08e2\3\2\2\2\u08e2\u08e4\3\2\2\2") + buf.write("\u08e3\u08e5\5\u01f8\u00fd\2\u08e4\u08e3\3\2\2\2\u08e4") + buf.write("\u08e5\3\2\2\2\u08e5\u08e7\3\2\2\2\u08e6\u08c4\3\2\2\2") + buf.write("\u08e6\u08ce\3\2\2\2\u08e6\u08d7\3\2\2\2\u08e7\u008b\3") + buf.write("\2\2\2\u08e8\u08e9\7\u00e6\2\2\u08e9\u08ea\7\u0187\2\2") + buf.write("\u08ea\u08eb\5\u0230\u0119\2\u08eb\u008d\3\2\2\2\u08ec") + buf.write("\u08ed\7I\2\2\u08ed\u08ee\7\u0187\2\2\u08ee\u008f\3\2") + buf.write("\2\2\u08ef\u08f1\7\u01b5\2\2\u08f0\u08ef\3\2\2\2\u08f0") + buf.write("\u08f1\3\2\2\2\u08f1\u08f2\3\2\2\2\u08f2\u08f4\7q\2\2") + buf.write("\u08f3\u08f5\7\u015c\2\2\u08f4\u08f3\3\2\2\2\u08f4\u08f5") + buf.write("\3\2\2\2\u08f5\u08f7\3\2\2\2\u08f6\u08f8\5\u019a\u00ce") + buf.write("\2\u08f7\u08f6\3\2\2\2\u08f7\u08f8\3\2\2\2\u08f8\u08fa") + buf.write("\3\2\2\2\u08f9\u08fb\5\u0210\u0109\2\u08fa\u08f9\3\2\2") + buf.write("\2\u08fa\u08fb\3\2\2\2\u08fb\u08fc\3\2\2\2\u08fc\u08fe") + buf.write("\7\u01a3\2\2\u08fd\u08ff\7\u01a4\2\2\u08fe\u08fd\3\2\2") + buf.write("\2\u08fe\u08ff\3\2\2\2\u08ff\u0900\3\2\2\2\u0900\u0901") + buf.write("\5\u026a\u0136\2\u0901\u0902\5\u0092J\2\u0902\u0091\3") + buf.write("\2\2\2\u0903\u0904\7\u01b7\2\2\u0904\u0906\5\u0210\u0109") + buf.write("\2\u0905\u0903\3\2\2\2\u0905\u0906\3\2\2\2\u0906\u0907") + buf.write("\3\2\2\2\u0907\u0909\5\u0094K\2\u0908\u090a\5\u0096L\2") + buf.write("\u0909\u0908\3\2\2\2\u0909\u090a\3\2\2\2\u090a\u090c\3") + buf.write("\2\2\2\u090b\u090d\5\u01e2\u00f2\2\u090c\u090b\3\2\2\2") + buf.write("\u090c\u090d\3\2\2\2\u090d\u090f\3\2\2\2\u090e\u0910\5") + buf.write("\u01e8\u00f5\2\u090f\u090e\3\2\2\2\u090f\u0910\3\2\2\2") + buf.write("\u0910\u0912\3\2\2\2\u0911\u0913\5\u0098M\2\u0912\u0911") + buf.write("\3\2\2\2\u0912\u0913\3\2\2\2\u0913\u0093\3\2\2\2\u0914") + buf.write("\u0915\7\u024b\2\2\u0915\u0916\5\u029a\u014e\2\u0916\u0917") + buf.write("\7\u024c\2\2\u0917\u0095\3\2\2\2\u0918\u0919\7n\2\2\u0919") + buf.write("\u091a\7\u024b\2\2\u091a\u091f\5\u0210\u0109\2\u091b\u091c") + buf.write("\7\u0245\2\2\u091c\u091e\5\u0210\u0109\2\u091d\u091b\3") + buf.write("\2\2\2\u091e\u0921\3\2\2\2\u091f\u091d\3\2\2\2\u091f\u0920") + buf.write("\3\2\2\2\u0920\u0922\3\2\2\2\u0921\u091f\3\2\2\2\u0922") + buf.write("\u0923\7\u024c\2\2\u0923\u0097\3\2\2\2\u0924\u0925\7\u01ba") + buf.write("\2\2\u0925\u0926\5\u0230\u0119\2\u0926\u0099\3\2\2\2\u0927") + buf.write("\u0929\7V\2\2\u0928\u092a\5\u019a\u00ce\2\u0929\u0928") + buf.write("\3\2\2\2\u0929\u092a\3\2\2\2\u092a\u092b\3\2\2\2\u092b") + buf.write("\u092d\5\u0210\u0109\2\u092c\u092e\7\u01bc\2\2\u092d\u092c") + buf.write("\3\2\2\2\u092d\u092e\3\2\2\2\u092e\u0931\3\2\2\2\u092f") + buf.write("\u0930\7\u00db\2\2\u0930\u0932\5\u0210\u0109\2\u0931\u092f") + buf.write("\3\2\2\2\u0931\u0932\3\2\2\2\u0932\u0938\3\2\2\2\u0933") + buf.write("\u0936\7\u0119\2\2\u0934\u0937\5\u0210\u0109\2\u0935\u0937") + buf.write("\5\u0146\u00a4\2\u0936\u0934\3\2\2\2\u0936\u0935\3\2\2") + buf.write("\2\u0937\u0939\3\2\2\2\u0938\u0933\3\2\2\2\u0938\u0939") + buf.write("\3\2\2\2\u0939\u093f\3\2\2\2\u093a\u093d\7\u0193\2\2\u093b") + buf.write("\u093e\5\u0210\u0109\2\u093c\u093e\5\u0146\u00a4\2\u093d") + buf.write("\u093b\3\2\2\2\u093d\u093c\3\2\2\2\u093e\u0940\3\2\2\2") + buf.write("\u093f\u093a\3\2\2\2\u093f\u0940\3\2\2\2\u0940\u0942\3") + buf.write("\2\2\2\u0941\u0943\7\32\2\2\u0942\u0941\3\2\2\2\u0942") + buf.write("\u0943\3\2\2\2\u0943\u009b\3\2\2\2\u0944\u0945\7\u01a5") + buf.write("\2\2\u0945\u0947\7\u00cc\2\2\u0946\u0944\3\2\2\2\u0946") + buf.write("\u0947\3\2\2\2\u0947\u0949\3\2\2\2\u0948\u094a\7\u0108") + buf.write("\2\2\u0949\u0948\3\2\2\2\u0949\u094a\3\2\2\2\u094a\u094c") + buf.write("\3\2\2\2\u094b\u094d\7\u00b9\2\2\u094c\u094b\3\2\2\2\u094c") + buf.write("\u094d\3\2\2\2\u094d\u094e\3\2\2\2\u094e\u094f\7~\2\2") + buf.write("\u094f\u095a\5\u0210\u0109\2\u0950\u0951\7d\2\2\u0951") + buf.write("\u0954\5\u026a\u0136\2\u0952\u0953\7u\2\2\u0953\u0955") + buf.write("\5\u026a\u0136\2\u0954\u0952\3\2\2\2\u0954\u0955\3\2\2") + buf.write("\2\u0955\u0958\3\2\2\2\u0956\u0957\7\u0116\2\2\u0957\u0959") + buf.write("\5\u026a\u0136\2\u0958\u0956\3\2\2\2\u0958\u0959\3\2\2") + buf.write("\2\u0959\u095b\3\2\2\2\u095a\u0950\3\2\2\2\u095a\u095b") + buf.write("\3\2\2\2\u095b\u009d\3\2\2\2\u095c\u095d\7P\2\2\u095d") + buf.write("\u095e\7\u0106\2\2\u095e\u095f\5\u0210\u0109\2\u095f\u0960") + buf.write("\7\u01a3\2\2\u0960\u0975\5\u0210\u0109\2\u0961\u0971\7") + buf.write("\u01b9\2\2\u0962\u0963\5\u026a\u0136\2\u0963\u0964\7\u0197") + buf.write("\2\2\u0964\u0965\7\u024b\2\2\u0965\u096a\5\u0146\u00a4") + buf.write("\2\u0966\u0967\7\u0245\2\2\u0967\u0969\5\u0146\u00a4\2") + buf.write("\u0968\u0966\3\2\2\2\u0969\u096c\3\2\2\2\u096a\u0968\3") + buf.write("\2\2\2\u096a\u096b\3\2\2\2\u096b\u096d\3\2\2\2\u096c\u096a") + buf.write("\3\2\2\2\u096d\u096f\7\u024c\2\2\u096e\u0970\7\u0173\2") + buf.write("\2\u096f\u096e\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0972") + buf.write("\3\2\2\2\u0971\u0962\3\2\2\2\u0972\u0973\3\2\2\2\u0973") + buf.write("\u0971\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u0976\3\2\2\2") + buf.write("\u0975\u0961\3\2\2\2\u0975\u0976\3\2\2\2\u0976\u0977\3") + buf.write("\2\2\2\u0977\u0978\7T\2\2\u0978\u0979\t\22\2\2\u0979\u097a") + buf.write("\5\u0230\u0119\2\u097a\u009f\3\2\2\2\u097b\u097c\7\u0109") + buf.write("\2\2\u097c\u0a10\5\u026a\u0136\2\u097d\u09c2\7\u0176\2") + buf.write("\2\u097e\u0987\7\u024b\2\2\u097f\u0984\5\u01c8\u00e5\2") + buf.write("\u0980\u0981\7\u0245\2\2\u0981\u0983\5\u01c8\u00e5\2\u0982") + buf.write("\u0980\3\2\2\2\u0983\u0986\3\2\2\2\u0984\u0982\3\2\2\2") + buf.write("\u0984\u0985\3\2\2\2\u0985\u0988\3\2\2\2\u0986\u0984\3") + buf.write("\2\2\2\u0987\u097f\3\2\2\2\u0987\u0988\3\2\2\2\u0988\u0989") + buf.write("\3\2\2\2\u0989\u09c3\7\u024c\2\2\u098a\u098b\7N\2\2\u098b") + buf.write("\u0994\7\u024b\2\2\u098c\u0991\5\u0146\u00a4\2\u098d\u098e") + buf.write("\7\u0245\2\2\u098e\u0990\5\u0146\u00a4\2\u098f\u098d\3") + buf.write("\2\2\2\u0990\u0993\3\2\2\2\u0991\u098f\3\2\2\2\u0991\u0992") + buf.write("\3\2\2\2\u0992\u0995\3\2\2\2\u0993\u0991\3\2\2\2\u0994") + buf.write("\u098c\3\2\2\2\u0994\u0995\3\2\2\2\u0995\u0996\3\2\2\2") + buf.write("\u0996\u09c3\7\u024c\2\2\u0997\u0998\7\u00bf\2\2\u0998") + buf.write("\u09a8\7\u024b\2\2\u0999\u099a\7\u0216\2\2\u099a\u099b") + buf.write("\7\u0242\2\2\u099b\u09a9\5\u0224\u0113\2\u099c\u099d\7") + buf.write("\u0215\2\2\u099d\u099e\7\u0242\2\2\u099e\u09a9\5\u0210") + buf.write("\u0109\2\u099f\u09a0\7\u015b\2\2\u09a0\u09a1\7\u0242\2") + buf.write("\2\u09a1\u09a9\5\u026a\u0136\2\u09a2\u09a3\7\u01c1\2\2") + buf.write("\u09a3\u09a4\7\u0242\2\2\u09a4\u09a9\5\u026a\u0136\2\u09a5") + buf.write("\u09a6\7\u0214\2\2\u09a6\u09a7\7\u0242\2\2\u09a7\u09a9") + buf.write("\5\u026a\u0136\2\u09a8\u0999\3\2\2\2\u09a8\u099c\3\2\2") + buf.write("\2\u09a8\u099f\3\2\2\2\u09a8\u09a2\3\2\2\2\u09a8\u09a5") + buf.write("\3\2\2\2\u09a8\u09a9\3\2\2\2\u09a9\u09be\3\2\2\2\u09aa") + buf.write("\u09ba\7\u0245\2\2\u09ab\u09ac\7\u0216\2\2\u09ac\u09ad") + buf.write("\7\u0242\2\2\u09ad\u09bb\5\u0224\u0113\2\u09ae\u09af\7") + buf.write("\u0215\2\2\u09af\u09b0\7\u0242\2\2\u09b0\u09bb\5\u0210") + buf.write("\u0109\2\u09b1\u09b2\7\u015b\2\2\u09b2\u09b3\7\u0242\2") + buf.write("\2\u09b3\u09bb\5\u026a\u0136\2\u09b4\u09b5\7\u01c1\2\2") + buf.write("\u09b5\u09b6\7\u0242\2\2\u09b6\u09bb\5\u026a\u0136\2\u09b7") + buf.write("\u09b8\7\u0214\2\2\u09b8\u09b9\7\u0242\2\2\u09b9\u09bb") + buf.write("\5\u026a\u0136\2\u09ba\u09ab\3\2\2\2\u09ba\u09ae\3\2\2") + buf.write("\2\u09ba\u09b1\3\2\2\2\u09ba\u09b4\3\2\2\2\u09ba\u09b7") + buf.write("\3\2\2\2\u09bb\u09bd\3\2\2\2\u09bc\u09aa\3\2\2\2\u09bd") + buf.write("\u09c0\3\2\2\2\u09be\u09bc\3\2\2\2\u09be\u09bf\3\2\2\2") + buf.write("\u09bf\u09c1\3\2\2\2\u09c0\u09be\3\2\2\2\u09c1\u09c3\7") + buf.write("\u024c\2\2\u09c2\u097e\3\2\2\2\u09c2\u098a\3\2\2\2\u09c2") + buf.write("\u0997\3\2\2\2\u09c3\u0a11\3\2\2\2\u09c4\u09cc\7\u024b") + buf.write("\2\2\u09c5\u09c6\7\u01de\2\2\u09c6\u09c9\7\u0242\2\2\u09c7") + buf.write("\u09ca\5\u0152\u00aa\2\u09c8\u09ca\7\u021e\2\2\u09c9\u09c7") + buf.write("\3\2\2\2\u09c9\u09c8\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb") + buf.write("\u09cd\7\u0245\2\2\u09cc\u09c5\3\2\2\2\u09cc\u09cd\3\2") + buf.write("\2\2\u09cd\u09ce\3\2\2\2\u09ce\u09cf\7v\2\2\u09cf\u09d0") + buf.write("\7\u0242\2\2\u09d0\u09d1\5\u026a\u0136\2\u09d1\u09d2\7") + buf.write("\u0245\2\2\u09d2\u09d3\7\u01fb\2\2\u09d3\u09d4\7\u0242") + buf.write("\2\2\u09d4\u0a0b\5\u026a\u0136\2\u09d5\u0a07\7\u0245\2") + buf.write("\2\u09d6\u09d7\7\u0204\2\2\u09d7\u09d8\7\u0242\2\2\u09d8") + buf.write("\u0a08\5\u026a\u0136\2\u09d9\u09da\7\u020b\2\2\u09da\u09db") + buf.write("\7\u0242\2\2\u09db\u0a08\5\u026a\u0136\2\u09dc\u09dd\7") + buf.write("\u021a\2\2\u09dd\u09de\7\u0242\2\2\u09de\u0a08\5\u026a") + buf.write("\u0136\2\u09df\u09e0\7\u021b\2\2\u09e0\u09e1\7\u0242\2") + buf.write("\2\u09e1\u0a08\5\u026a\u0136\2\u09e2\u09e3\7\u0172\2\2") + buf.write("\u09e3\u09e4\7\u0242\2\2\u09e4\u0a08\5\u026a\u0136\2\u09e5") + buf.write("\u09e6\7\u01de\2\2\u09e6\u09e9\7\u0242\2\2\u09e7\u09ea") + buf.write("\5\u0152\u00aa\2\u09e8\u09ea\7\u021e\2\2\u09e9\u09e7\3") + buf.write("\2\2\2\u09e9\u09e8\3\2\2\2\u09ea\u0a08\3\2\2\2\u09eb\u0a08") + buf.write("\7\u01fc\2\2\u09ec\u09ed\7\u01bd\2\2\u09ed\u09ee\7\u0242") + buf.write("\2\2\u09ee\u0a08\5\u0224\u0113\2\u09ef\u09f0\7\u00f5\2") + buf.write("\2\u09f0\u09f1\7\u0242\2\2\u09f1\u0a08\t\30\2\2\u09f2") + buf.write("\u09f3\7\u0167\2\2\u09f3\u09f4\7\u0242\2\2\u09f4\u0a08") + buf.write("\5\u0224\u0113\2\u09f5\u09f6\7\u01c2\2\2\u09f6\u09f7\7") + buf.write("\u0242\2\2\u09f7\u0a08\5\u0146\u00a4\2\u09f8\u09f9\7\u0200") + buf.write("\2\2\u09f9\u09fa\7\u0242\2\2\u09fa\u0a08\5\u0240\u0121") + buf.write("\2\u09fb\u09fc\7\u0187\2\2\u09fc\u09fd\7\u0242\2\2\u09fd") + buf.write("\u0a08\5\u0230\u0119\2\u09fe\u09ff\7\u01cd\2\2\u09ff\u0a00") + buf.write("\7\u0242\2\2\u0a00\u0a08\5\u0224\u0113\2\u0a01\u0a02\7") + buf.write("?\2\2\u0a02\u0a03\7\u0242\2\2\u0a03\u0a08\5\u0146\u00a4") + buf.write("\2\u0a04\u0a05\7\u01c3\2\2\u0a05\u0a06\7\u0242\2\2\u0a06") + buf.write("\u0a08\5\u0240\u0121\2\u0a07\u09d6\3\2\2\2\u0a07\u09d9") + buf.write("\3\2\2\2\u0a07\u09dc\3\2\2\2\u0a07\u09df\3\2\2\2\u0a07") + buf.write("\u09e2\3\2\2\2\u0a07\u09e5\3\2\2\2\u0a07\u09eb\3\2\2\2") + buf.write("\u0a07\u09ec\3\2\2\2\u0a07\u09ef\3\2\2\2\u0a07\u09f2\3") + buf.write("\2\2\2\u0a07\u09f5\3\2\2\2\u0a07\u09f8\3\2\2\2\u0a07\u09fb") + buf.write("\3\2\2\2\u0a07\u09fe\3\2\2\2\u0a07\u0a01\3\2\2\2\u0a07") + buf.write("\u0a04\3\2\2\2\u0a08\u0a0a\3\2\2\2\u0a09\u09d5\3\2\2\2") + buf.write("\u0a0a\u0a0d\3\2\2\2\u0a0b\u0a09\3\2\2\2\u0a0b\u0a0c\3") + buf.write("\2\2\2\u0a0c\u0a0e\3\2\2\2\u0a0d\u0a0b\3\2\2\2\u0a0e\u0a0f") + buf.write("\7\u024c\2\2\u0a0f\u0a11\3\2\2\2\u0a10\u097d\3\2\2\2\u0a10") + buf.write("\u09c4\3\2\2\2\u0a10\u0a11\3\2\2\2\u0a11\u00a1\3\2\2\2") + buf.write("\u0a12\u0a13\7G\2\2\u0a13\u0a15\5\u026a\u0136\2\u0a14") + buf.write("\u0a16\7\u0176\2\2\u0a15\u0a14\3\2\2\2\u0a15\u0a16\3\2") + buf.write("\2\2\u0a16\u0a17\3\2\2\2\u0a17\u0a1e\5\u0224\u0113\2\u0a18") + buf.write("\u0a1d\5\u01fa\u00fe\2\u0a19\u0a1a\7\u0187\2\2\u0a1a\u0a1d") + buf.write("\5\u0230\u0119\2\u0a1b\u0a1d\5\u00dep\2\u0a1c\u0a18\3") + buf.write("\2\2\2\u0a1c\u0a19\3\2\2\2\u0a1c\u0a1b\3\2\2\2\u0a1d\u0a20") + buf.write("\3\2\2\2\u0a1e\u0a1c\3\2\2\2\u0a1e\u0a1f\3\2\2\2\u0a1f") + buf.write("\u00a3\3\2\2\2\u0a20\u0a1e\3\2\2\2\u0a21\u0a23\7\u00e4") + buf.write("\2\2\u0a22\u0a24\5\u019a\u00ce\2\u0a23\u0a22\3\2\2\2\u0a23") + buf.write("\u0a24\3\2\2\2\u0a24\u0a25\3\2\2\2\u0a25\u0a28\5\u0210") + buf.write("\u0109\2\u0a26\u0a27\7\u0109\2\2\u0a27\u0a29\5\u0146\u00a4") + buf.write("\2\u0a28\u0a26\3\2\2\2\u0a28\u0a29\3\2\2\2\u0a29\u0a2c") + buf.write("\3\2\2\2\u0a2a\u0a2b\7\u0119\2\2\u0a2b\u0a2d\5\u0146\u00a4") + buf.write("\2\u0a2c\u0a2a\3\2\2\2\u0a2c\u0a2d\3\2\2\2\u0a2d\u0a2e") + buf.write("\3\2\2\2\u0a2e\u0a2f\7\u0192\2\2\u0a2f\u0a30\7\66\2\2") + buf.write("\u0a30\u0a31\7\u0121\2\2\u0a31\u0a33\5\u0210\u0109\2\u0a32") + buf.write("\u0a34\5\u01bc\u00df\2\u0a33\u0a32\3\2\2\2\u0a33\u0a34") + buf.write("\3\2\2\2\u0a34\u00a5\3\2\2\2\u0a35\u0a36\7\u0102\2\2\u0a36") + buf.write("\u0a37\7\u00de\2\2\u0a37\u0a38\7C\2\2\u0a38\u0a39\5\u026a") + buf.write("\u0136\2\u0a39\u0a3a\7\u024b\2\2\u0a3a\u0a3b\7\u0100\2") + buf.write("\2\u0a3b\u0a3c\7\u0242\2\2\u0a3c\u0a41\5\u026a\u0136\2") + buf.write("\u0a3d\u0a3e\7\u0245\2\2\u0a3e\u0a40\5\u00a8U\2\u0a3f") + buf.write("\u0a3d\3\2\2\2\u0a40\u0a43\3\2\2\2\u0a41\u0a3f\3\2\2\2") + buf.write("\u0a41\u0a42\3\2\2\2\u0a42\u0a44\3\2\2\2\u0a43\u0a41\3") + buf.write("\2\2\2\u0a44\u0a45\7\u024c\2\2\u0a45\u00a7\3\2\2\2\u0a46") + buf.write("\u0a47\5\u0210\u0109\2\u0a47\u0a48\7\u0242\2\2\u0a48\u0a49") + buf.write("\5\u0230\u0119\2\u0a49\u00a9\3\2\2\2\u0a4a\u0a4b\7\u0102") + buf.write("\2\2\u0a4b\u0a4c\7\u00de\2\2\u0a4c\u0a4d\7(\2\2\u0a4d") + buf.write("\u0a4e\5\u026a\u0136\2\u0a4e\u0a55\7\u024b\2\2\u0a4f\u0a50") + buf.write("\7\u00ac\2\2\u0a50\u0a51\7\u0242\2\2\u0a51\u0a56\5\u026a") + buf.write("\u0136\2\u0a52\u0a53\7/\2\2\u0a53\u0a54\7\u0242\2\2\u0a54") + buf.write("\u0a56\5\u026a\u0136\2\u0a55\u0a4f\3\2\2\2\u0a55\u0a52") + buf.write("\3\2\2\2\u0a56\u0a57\3\2\2\2\u0a57\u0a58\7\u024c\2\2\u0a58") + buf.write("\u00ab\3\2\2\2\u0a59\u0a5a\7\u0102\2\2\u0a5a\u0a5b\7\u00de") + buf.write("\2\2\u0a5b\u0a5c\7\u0100\2\2\u0a5c\u0a5d\5\u026a\u0136") + buf.write("\2\u0a5d\u0a63\7\u024b\2\2\u0a5e\u0a5f\7\u01dc\2\2\u0a5f") + buf.write("\u0a60\7\u0242\2\2\u0a60\u0a61\5\u026a\u0136\2\u0a61\u0a62") + buf.write("\7\u0245\2\2\u0a62\u0a64\3\2\2\2\u0a63\u0a5e\3\2\2\2\u0a63") + buf.write("\u0a64\3\2\2\2\u0a64\u0a65\3\2\2\2\u0a65\u0a66\7\u01e3") + buf.write("\2\2\u0a66\u0a67\7\u0242\2\2\u0a67\u0a6c\5\u026a\u0136") + buf.write("\2\u0a68\u0a69\7\u0245\2\2\u0a69\u0a6a\7\u01dc\2\2\u0a6a") + buf.write("\u0a6b\7\u0242\2\2\u0a6b\u0a6d\5\u026a\u0136\2\u0a6c\u0a68") + buf.write("\3\2\2\2\u0a6c\u0a6d\3\2\2\2\u0a6d\u0a6e\3\2\2\2\u0a6e") + buf.write("\u0a6f\7\u024c\2\2\u0a6f\u00ad\3\2\2\2\u0a70\u0a71\7\u0102") + buf.write("\2\2\u0a71\u0a72\7\u00de\2\2\u0a72\u0a73\7\u00ac\2\2\u0a73") + buf.write("\u0a74\5\u026a\u0136\2\u0a74\u0a75\7\u024b\2\2\u0a75\u0a76") + buf.write("\7\u00f0\2\2\u0a76\u0a77\7\u0242\2\2\u0a77\u0a78\5\u026a") + buf.write("\u0136\2\u0a78\u0a79\7\u0245\2\2\u0a79\u0a7a\7\u01d6\2") + buf.write("\2\u0a7a\u0a7b\7\u0242\2\2\u0a7b\u0a7c\5\u026a\u0136\2") + buf.write("\u0a7c\u0a7d\7\u0245\2\2\u0a7d\u0a7e\7\u018d\2\2\u0a7e") + buf.write("\u0a7f\7\u0242\2\2\u0a7f\u0a80\5\u026a\u0136\2\u0a80\u0a86") + buf.write("\7\u0245\2\2\u0a81\u0a82\7\u01d9\2\2\u0a82\u0a83\7\u0242") + buf.write("\2\2\u0a83\u0a84\5\u026a\u0136\2\u0a84\u0a85\7\u0245\2") + buf.write("\2\u0a85\u0a87\3\2\2\2\u0a86\u0a81\3\2\2\2\u0a86\u0a87") + buf.write("\3\2\2\2\u0a87\u0a88\3\2\2\2\u0a88\u0a89\7\u01e4\2\2\u0a89") + buf.write("\u0a8a\7\u0242\2\2\u0a8a\u0a8f\5\u026a\u0136\2\u0a8b\u0a8c") + buf.write("\7\u0245\2\2\u0a8c\u0a8d\7\u01d9\2\2\u0a8d\u0a8e\7\u0242") + buf.write("\2\2\u0a8e\u0a90\5\u026a\u0136\2\u0a8f\u0a8b\3\2\2\2\u0a8f") + buf.write("\u0a90\3\2\2\2\u0a90\u0a91\3\2\2\2\u0a91\u0a92\7\u024c") + buf.write("\2\2\u0a92\u00af\3\2\2\2\u0a93\u0a95\7\u015b\2\2\u0a94") + buf.write("\u0a96\5\u019a\u00ce\2\u0a95\u0a94\3\2\2\2\u0a95\u0a96") + buf.write("\3\2\2\2\u0a96\u0a97\3\2\2\2\u0a97\u0aa6\5\u026a\u0136") + buf.write("\2\u0a98\u0a99\7\u0193\2\2\u0a99\u0aa7\5\u026a\u0136\2") + buf.write("\u0a9a\u0aa3\7\u024b\2\2\u0a9b\u0aa0\5\u00b4[\2\u0a9c") + buf.write("\u0a9d\7\u0245\2\2\u0a9d\u0a9f\5\u00b4[\2\u0a9e\u0a9c") + buf.write("\3\2\2\2\u0a9f\u0aa2\3\2\2\2\u0aa0\u0a9e\3\2\2\2\u0aa0") + buf.write("\u0aa1\3\2\2\2\u0aa1\u0aa4\3\2\2\2\u0aa2\u0aa0\3\2\2\2") + buf.write("\u0aa3\u0a9b\3\2\2\2\u0aa3\u0aa4\3\2\2\2\u0aa4\u0aa5\3") + buf.write("\2\2\2\u0aa5\u0aa7\7\u024c\2\2\u0aa6\u0a98\3\2\2\2\u0aa6") + buf.write("\u0a9a\3\2\2\2\u0aa7\u00b1\3\2\2\2\u0aa8\u0aa9\7\u015b") + buf.write("\2\2\u0aa9\u0aaf\5\u026a\u0136\2\u0aaa\u0aab\7\u00c6\2") + buf.write("\2\u0aab\u0ab0\7\u0119\2\2\u0aac\u0ab0\5\u01ee\u00f8\2") + buf.write("\u0aad\u0ab0\5\u01ec\u00f7\2\u0aae\u0ab0\5\u01f0\u00f9") + buf.write("\2\u0aaf\u0aaa\3\2\2\2\u0aaf\u0aac\3\2\2\2\u0aaf\u0aad") + buf.write("\3\2\2\2\u0aaf\u0aae\3\2\2\2\u0ab0\u00b3\3\2\2\2\u0ab1") + buf.write("\u0ab2\t\"\2\2\u0ab2\u0ab5\7\u0242\2\2\u0ab3\u0ab6\5\u0146") + buf.write("\u00a4\2\u0ab4\u0ab6\5\u0210\u0109\2\u0ab5\u0ab3\3\2\2") + buf.write("\2\u0ab5\u0ab4\3\2\2\2\u0ab6\u0abb\3\2\2\2\u0ab7\u0ab8") + buf.write("\7\u01cb\2\2\u0ab8\u0ab9\7\u0242\2\2\u0ab9\u0abb\58\35") + buf.write("\2\u0aba\u0ab1\3\2\2\2\u0aba\u0ab7\3\2\2\2\u0abb\u00b5") + buf.write("\3\2\2\2\u0abc\u0abd\7\u01b6\2\2\u0abd\u0abf\7\u008a\2") + buf.write("\2\u0abe\u0ac0\5\u019a\u00ce\2\u0abf\u0abe\3\2\2\2\u0abf") + buf.write("\u0ac0\3\2\2\2\u0ac0\u0ac1\3\2\2\2\u0ac1\u0ac4\7\u0191") + buf.write("\2\2\u0ac2\u0ac5\5,\27\2\u0ac3\u0ac5\7\u01b6\2\2\u0ac4") + buf.write("\u0ac2\3\2\2\2\u0ac4\u0ac3\3\2\2\2\u0ac5\u0ac6\3\2\2\2") + buf.write("\u0ac6\u0ac7\7\u00e4\2\2\u0ac7\u0ac9\5\u0210\u0109\2\u0ac8") + buf.write("\u0aca\5\u01bc\u00df\2\u0ac9\u0ac8\3\2\2\2\u0ac9\u0aca") + buf.write("\3\2\2\2\u0aca\u00b7\3\2\2\2\u0acb\u0acc\7\u01b6\2\2\u0acc") + buf.write("\u0acd\7\u008a\2\2\u0acd\u0ad0\7\u0191\2\2\u0ace\u0ad1") + buf.write("\5,\27\2\u0acf\u0ad1\7\u01b6\2\2\u0ad0\u0ace\3\2\2\2\u0ad0") + buf.write("\u0acf\3\2\2\2\u0ad1\u0ad2\3\2\2\2\u0ad2\u0ad3\7\u00e4") + buf.write("\2\2\u0ad3\u0ad5\5\u0210\u0109\2\u0ad4\u0ad6\5\u01bc\u00df") + buf.write("\2\u0ad5\u0ad4\3\2\2\2\u0ad5\u0ad6\3\2\2\2\u0ad6\u00b9") + buf.write("\3\2\2\2\u0ad7\u0ae5\t\35\2\2\u0ad8\u0ae6\5\u00bc_\2\u0ad9") + buf.write("\u0ada\5\u0210\u0109\2\u0ada\u0adb\5\u01ee\u00f8\2\u0adb") + buf.write("\u0ae6\3\2\2\2\u0adc\u0ade\5,\27\2\u0add\u0adf\7\u01bc") + buf.write("\2\2\u0ade\u0add\3\2\2\2\u0ade\u0adf\3\2\2\2\u0adf\u0ae1") + buf.write("\3\2\2\2\u0ae0\u0ae2\5\u00e8u\2\u0ae1\u0ae0\3\2\2\2\u0ae2") + buf.write("\u0ae3\3\2\2\2\u0ae3\u0ae1\3\2\2\2\u0ae3\u0ae4\3\2\2\2") + buf.write("\u0ae4\u0ae6\3\2\2\2\u0ae5\u0ad8\3\2\2\2\u0ae5\u0ad9\3") + buf.write("\2\2\2\u0ae5\u0adc\3\2\2\2\u0ae6\u00bb\3\2\2\2\u0ae7\u0aea") + buf.write("\5,\27\2\u0ae8\u0aea\7\u0170\2\2\u0ae9\u0ae7\3\2\2\2\u0ae9") + buf.write("\u0ae8\3\2\2\2\u0aea\u0aee\3\2\2\2\u0aeb\u0aec\7\u0197") + buf.write("\2\2\u0aec\u0aed\7\67\2\2\u0aed\u0aef\5\u0210\u0109\2") + buf.write("\u0aee\u0aeb\3\2\2\2\u0aee\u0aef\3\2\2\2\u0aef\u0af0\3") + buf.write("\2\2\2\u0af0\u0af1\5\u00be`\2\u0af1\u00bd\3\2\2\2\u0af2") + buf.write("\u0af6\7\u00e6\2\2\u0af3\u0af4\5\u0210\u0109\2\u0af4\u0af5") + buf.write("\7\u0253\2\2\u0af5\u0af7\3\2\2\2\u0af6\u0af3\3\2\2\2\u0af6") + buf.write("\u0af7\3\2\2\2\u0af7\u0af8\3\2\2\2\u0af8\u0af9\5\u0210") + buf.write("\u0109\2\u0af9\u0afa\t\34\2\2\u0afa\u0afb\5\u010c\u0087") + buf.write("\2\u0afb\u0b10\3\2\2\2\u0afc\u0b00\7\u00e6\2\2\u0afd\u0afe") + buf.write("\5\u0210\u0109\2\u0afe\u0aff\7\u0253\2\2\u0aff\u0b01\3") + buf.write("\2\2\2\u0b00\u0afd\3\2\2\2\u0b00\u0b01\3\2\2\2\u0b01\u0b02") + buf.write("\3\2\2\2\u0b02\u0b03\5\u0210\u0109\2\u0b03\u0b04\7\u0193") + buf.write("\2\2\u0b04\u0b05\7\63\2\2\u0b05\u0b10\3\2\2\2\u0b06\u0b0a") + buf.write("\7\u00ce\2\2\u0b07\u0b08\5\u0210\u0109\2\u0b08\u0b09\7") + buf.write("\u0253\2\2\u0b09\u0b0b\3\2\2\2\u0b0a\u0b07\3\2\2\2\u0b0a") + buf.write("\u0b0b\3\2\2\2\u0b0b\u0b0c\3\2\2\2\u0b0c\u0b10\5\u0210") + buf.write("\u0109\2\u0b0d\u0b0e\7\u00ce\2\2\u0b0e\u0b10\7\u0170\2") + buf.write("\2\u0b0f\u0af2\3\2\2\2\u0b0f\u0afc\3\2\2\2\u0b0f\u0b06") + buf.write("\3\2\2\2\u0b0f\u0b0d\3\2\2\2\u0b10\u00bf\3\2\2\2\u0b11") + buf.write("\u0b12\7\u0195\2\2\u0b12\u0b13\5\u00c2b\2\u0b13\u00c1") + buf.write("\3\2\2\2\u0b14\u0b15\5\u0210\u0109\2\u0b15\u0b16\5\u01ee") + buf.write("\u00f8\2\u0b16\u0b1d\3\2\2\2\u0b17\u0b18\5,\27\2\u0b18") + buf.write("\u0b19\t\23\2\2\u0b19\u0b1a\7\u01b6\2\2\u0b1a\u0b1b\5") + buf.write("\u02b6\u015c\2\u0b1b\u0b1d\3\2\2\2\u0b1c\u0b14\3\2\2\2") + buf.write("\u0b1c\u0b17\3\2\2\2\u0b1d\u00c3\3\2\2\2\u0b1e\u0b1f\7") + buf.write("\u00fe\2\2\u0b1f\u0b20\5\u0210\u0109\2\u0b20\u0b21\5\u00c8") + buf.write("e\2\u0b21\u00c5\3\2\2\2\u0b22\u0b23\7\u00a2\2\2\u0b23") + buf.write("\u0b40\5\u00dco\2\u0b24\u0b25\7\177\2\2\u0b25\u0b26\7") + buf.write("\u009d\2\2\u0b26\u0b40\7\u0262\2\2\u0b27\u0b28\t#\2\2") + buf.write("\u0b28\u0b29\5\u026a\u0136\2\u0b29\u0b2a\5\u0142\u00a2") + buf.write("\2\u0b2a\u0b40\3\2\2\2\u0b2b\u0b2c\7\u0102\2\2\u0b2c\u0b2d") + buf.write("\7\u00de\2\2\u0b2d\u0b3a\7C\2\2\u0b2e\u0b2f\7\u0102\2") + buf.write("\2\u0b2f\u0b30\7\u00de\2\2\u0b30\u0b3a\7(\2\2\u0b31\u0b3a") + buf.write("\7G\2\2\u0b32\u0b3a\7\u00db\2\2\u0b33\u0b3a\7\u00e1\2") + buf.write("\2\u0b34\u0b3a\7\u0109\2\2\u0b35\u0b37\7\u008c\2\2\u0b36") + buf.write("\u0b35\3\2\2\2\u0b36\u0b37\3\2\2\2\u0b37\u0b38\3\2\2\2") + buf.write("\u0b38\u0b3a\7\u011a\2\2\u0b39\u0b2b\3\2\2\2\u0b39\u0b2e") + buf.write("\3\2\2\2\u0b39\u0b31\3\2\2\2\u0b39\u0b32\3\2\2\2\u0b39") + buf.write("\u0b33\3\2\2\2\u0b39\u0b34\3\2\2\2\u0b39\u0b36\3\2\2\2") + buf.write("\u0b3a\u0b3c\3\2\2\2\u0b3b\u0b3d\5\u0198\u00cd\2\u0b3c") + buf.write("\u0b3b\3\2\2\2\u0b3c\u0b3d\3\2\2\2\u0b3d\u0b3e\3\2\2\2") + buf.write("\u0b3e\u0b40\5\u026a\u0136\2\u0b3f\u0b22\3\2\2\2\u0b3f") + buf.write("\u0b24\3\2\2\2\u0b3f\u0b27\3\2\2\2\u0b3f\u0b39\3\2\2\2") + buf.write("\u0b40\u0b41\3\2\2\2\u0b41\u0b42\5\u01ec\u00f7\2\u0b42") + buf.write("\u00c7\3\2\2\2\u0b43\u0b57\5\u01ee\u00f8\2\u0b44\u0b57") + buf.write("\5\u01ec\u00f7\2\u0b45\u0b46\7\u00e6\2\2\u0b46\u0b47\7") + buf.write("\u024b\2\2\u0b47\u0b4c\5\u00a8U\2\u0b48\u0b49\7\u0245") + buf.write("\2\2\u0b49\u0b4b\5\u00a8U\2\u0b4a\u0b48\3\2\2\2\u0b4b") + buf.write("\u0b4e\3\2\2\2\u0b4c\u0b4a\3\2\2\2\u0b4c\u0b4d\3\2\2\2") + buf.write("\u0b4d\u0b4f\3\2\2\2\u0b4e\u0b4c\3\2\2\2\u0b4f\u0b50\7") + buf.write("\u024c\2\2\u0b50\u0b57\3\2\2\2\u0b51\u0b52\7\u00ce\2\2") + buf.write("\u0b52\u0b53\7\u024b\2\2\u0b53\u0b54\5\u02b6\u015c\2\u0b54") + buf.write("\u0b55\7\u024c\2\2\u0b55\u0b57\3\2\2\2\u0b56\u0b43\3\2") + buf.write("\2\2\u0b56\u0b44\3\2\2\2\u0b56\u0b45\3\2\2\2\u0b56\u0b51") + buf.write("\3\2\2\2\u0b57\u00c9\3\2\2\2\u0b58\u0b59\7\u00f2\2\2\u0b59") + buf.write("\u0b5d\5\u026a\u0136\2\u0b5a\u0b5e\5\u01ee\u00f8\2\u0b5b") + buf.write("\u0b5e\5\u01f0\u00f9\2\u0b5c\u0b5e\5\u01ec\u00f7\2\u0b5d") + buf.write("\u0b5a\3\2\2\2\u0b5d\u0b5b\3\2\2\2\u0b5d\u0b5c\3\2\2\2") + buf.write("\u0b5e\u00cb\3\2\2\2\u0b5f\u0b60\7\u0192\2\2\u0b60\u0b61") + buf.write("\7\66\2\2\u0b61\u0b62\7\u0121\2\2\u0b62\u0b63\5\u0210") + buf.write("\u0109\2\u0b63\u0b64\5\u00ceh\2\u0b64\u00cd\3\2\2\2\u0b65") + buf.write("\u0b66\7d\2\2\u0b66\u0b6a\5\u0220\u0111\2\u0b67\u0b68") + buf.write("\7\u0098\2\2\u0b68\u0b6a\7d\2\2\u0b69\u0b65\3\2\2\2\u0b69") + buf.write("\u0b67\3\2\2\2\u0b69\u0b6a\3\2\2\2\u0b6a\u0b6f\3\2\2\2") + buf.write("\u0b6b\u0b6c\7\u0116\2\2\u0b6c\u0b70\5\u0220\u0111\2\u0b6d") + buf.write("\u0b6e\7\u0098\2\2\u0b6e\u0b70\7\u0116\2\2\u0b6f\u0b6b") + buf.write("\3\2\2\2\u0b6f\u0b6d\3\2\2\2\u0b6f\u0b70\3\2\2\2\u0b70") + buf.write("\u0b72\3\2\2\2\u0b71\u0b73\5\u01bc\u00df\2\u0b72\u0b71") + buf.write("\3\2\2\2\u0b72\u0b73\3\2\2\2\u0b73\u0b77\3\2\2\2\u0b74") + buf.write("\u0b77\5\u01ec\u00f7\2\u0b75\u0b77\5\u01ee\u00f8\2\u0b76") + buf.write("\u0b69\3\2\2\2\u0b76\u0b74\3\2\2\2\u0b76\u0b75\3\2\2\2") + buf.write("\u0b77\u00cf\3\2\2\2\u0b78\u0b79\7\u00a2\2\2\u0b79\u0b7a") + buf.write("\5\u00dco\2\u0b7a\u0b7b\5\u00d2j\2\u0b7b\u00d1\3\2\2\2") + buf.write("\u0b7c\u0b8a\5\u01f0\u00f9\2\u0b7d\u0b7e\7\u00e6\2\2\u0b7e") + buf.write("\u0b7f\7\u024b\2\2\u0b7f\u0b84\5\u00d4k\2\u0b80\u0b81") + buf.write("\7\u0245\2\2\u0b81\u0b83\5\u00d4k\2\u0b82\u0b80\3\2\2") + buf.write("\2\u0b83\u0b86\3\2\2\2\u0b84\u0b82\3\2\2\2\u0b84\u0b85") + buf.write("\3\2\2\2\u0b85\u0b87\3\2\2\2\u0b86\u0b84\3\2\2\2\u0b87") + buf.write("\u0b88\7\u024c\2\2\u0b88\u0b8a\3\2\2\2\u0b89\u0b7c\3\2") + buf.write("\2\2\u0b89\u0b7d\3\2\2\2\u0b8a\u00d3\3\2\2\2\u0b8b\u0b8c") + buf.write("\t$\2\2\u0b8c\u0b8d\7\u0242\2\2\u0b8d\u0b8e\5\u026a\u0136") + buf.write("\2\u0b8e\u00d5\3\2\2\2\u0b8f\u0b90\7\u01b6\2\2\u0b90\u0b92") + buf.write("\7\u008a\2\2\u0b91\u0b93\5\u0198\u00cd\2\u0b92\u0b91\3") + buf.write("\2\2\2\u0b92\u0b93\3\2\2\2\u0b93\u0b94\3\2\2\2\u0b94\u0b97") + buf.write("\7\u0191\2\2\u0b95\u0b98\5,\27\2\u0b96\u0b98\7\u01b6\2") + buf.write("\2\u0b97\u0b95\3\2\2\2\u0b97\u0b96\3\2\2\2\u0b98\u0b99") + buf.write("\3\2\2\2\u0b99\u0b9a\7\u00e4\2\2\u0b9a\u0b9b\5\u0210\u0109") + buf.write("\2\u0b9b\u00d7\3\2\2\2\u0b9c\u0b9d\7\u00a9\2\2\u0b9d\u0b9e") + buf.write("\7\26\2\2\u0b9e\u0ba3\5,\27\2\u0b9f\u0ba0\7\u0245\2\2") + buf.write("\u0ba0\u0ba2\5,\27\2\u0ba1\u0b9f\3\2\2\2\u0ba2\u0ba5\3") + buf.write("\2\2\2\u0ba3\u0ba1\3\2\2\2\u0ba3\u0ba4\3\2\2\2\u0ba4\u0ba7") + buf.write("\3\2\2\2\u0ba5\u0ba3\3\2\2\2\u0ba6\u0ba8\5\u01f8\u00fd") + buf.write("\2\u0ba7\u0ba6\3\2\2\2\u0ba7\u0ba8\3\2\2\2\u0ba8\u00d9") + buf.write("\3\2\2\2\u0ba9\u0bab\7\u00a2\2\2\u0baa\u0bac\5\u0198\u00cd") + buf.write("\2\u0bab\u0baa\3\2\2\2\u0bab\u0bac\3\2\2\2\u0bac\u0bad") + buf.write("\3\2\2\2\u0bad\u0bb2\5\u00dco\2\u0bae\u0baf\7\u0245\2") + buf.write("\2\u0baf\u0bb1\5\u00dco\2\u0bb0\u0bae\3\2\2\2\u0bb1\u0bb4") + buf.write("\3\2\2\2\u0bb2\u0bb0\3\2\2\2\u0bb2\u0bb3\3\2\2\2\u0bb3") + buf.write("\u0bb6\3\2\2\2\u0bb4\u0bb2\3\2\2\2\u0bb5\u0bb7\5\u01f8") + buf.write("\u00fd\2\u0bb6\u0bb5\3\2\2\2\u0bb6\u0bb7\3\2\2\2\u0bb7") + buf.write("\u00db\3\2\2\2\u0bb8\u0bb9\5\u00fe\u0080\2\u0bb9\u0bbc") + buf.write("\7\u024b\2\2\u0bba\u0bbd\5\u0224\u0113\2\u0bbb\u0bbd\7") + buf.write("\u013c\2\2\u0bbc\u0bba\3\2\2\2\u0bbc\u0bbb\3\2\2\2\u0bbd") + buf.write("\u0bbe\3\2\2\2\u0bbe\u0bc1\7\u0245\2\2\u0bbf\u0bc2\5\u0224") + buf.write("\u0113\2\u0bc0\u0bc2\7\u013c\2\2\u0bc1\u0bbf\3\2\2\2\u0bc1") + buf.write("\u0bc0\3\2\2\2\u0bc2\u0bc3\3\2\2\2\u0bc3\u0bc4\7\u024c") + buf.write("\2\2\u0bc4\u00dd\3\2\2\2\u0bc5\u0bc6\7\u017f\2\2\u0bc6") + buf.write("\u0bc8\5\u0210\u0109\2\u0bc7\u0bc5\3\2\2\2\u0bc7\u0bc8") + buf.write("\3\2\2\2\u0bc8\u0bd2\3\2\2\2\u0bc9\u0bca\7\u017c\2\2\u0bca") + buf.write("\u0bcb\7\u024b\2\2\u0bcb\u0bcc\5\u0230\u0119\2\u0bcc\u0bcd") + buf.write("\7\u024c\2\2\u0bcd\u0bd3\3\2\2\2\u0bce\u0bd0\7\u01a0\2") + buf.write("\2\u0bcf\u0bce\3\2\2\2\u0bcf\u0bd0\3\2\2\2\u0bd0\u0bd1") + buf.write("\3\2\2\2\u0bd1\u0bd3\7\u01a1\2\2\u0bd2\u0bc9\3\2\2\2\u0bd2") + buf.write("\u0bcf\3\2\2\2\u0bd3\u00df\3\2\2\2\u0bd4\u0bd5\7\u01a5") + buf.write("\2\2\u0bd5\u0bd7\7\u00cc\2\2\u0bd6\u0bd4\3\2\2\2\u0bd6") + buf.write("\u0bd7\3\2\2\2\u0bd7\u0bd8\3\2\2\2\u0bd8\u0bd9\7\u0105") + buf.write("\2\2\u0bd9\u0bda\7\u0191\2\2\u0bda\u0bdb\5\u0224\u0113") + buf.write("\2\u0bdb\u0bdc\7~\2\2\u0bdc\u0bdd\5\u0210\u0109\2\u0bdd") + buf.write("\u0bde\7\u024b\2\2\u0bde\u0bdf\7\u0193\2\2\u0bdf\u0be0") + buf.write("\7\u00ed\2\2\u0be0\u0be1\7\u01bc\2\2\u0be1\u0be2\7^\2") + buf.write("\2\u0be2\u0be3\5\u0140\u00a1\2\u0be3\u0be4\7\u0245\2\2") + buf.write("\u0be4\u0be5\7\u01b1\2\2\u0be5\u0be6\7\u00ed\2\2\u0be6") + buf.write("\u0be7\7\u01bc\2\2\u0be7\u0be8\7^\2\2\u0be8\u0be9\5\u0140") + buf.write("\u00a1\2\u0be9\u0bea\7\u024c\2\2\u0bea\u00e1\3\2\2\2\u0beb") + buf.write("\u0bec\7\5\2\2\u0bec\u0bed\7\u008e\2\2\u0bed\u0bee\5\u0210") + buf.write("\u0109\2\u0bee\u0bef\7\u0109\2\2\u0bef\u0bf0\t%\2\2\u0bf0") + buf.write("\u0bf1\7d\2\2\u0bf1\u0bf2\5\u026a\u0136\2\u0bf2\u00e3") + buf.write("\3\2\2\2\u0bf3\u0bf4\t\35\2\2\u0bf4\u0bff\5\u0210\u0109") + buf.write("\2\u0bf5\u0bf7\7\u01bc\2\2\u0bf6\u0bf5\3\2\2\2\u0bf6\u0bf7") + buf.write("\3\2\2\2\u0bf7\u0bf8\3\2\2\2\u0bf8\u0bfc\5\u00e6t\2\u0bf9") + buf.write("\u0bfb\5\u00e6t\2\u0bfa\u0bf9\3\2\2\2\u0bfb\u0bfe\3\2") + buf.write("\2\2\u0bfc\u0bfa\3\2\2\2\u0bfc\u0bfd\3\2\2\2\u0bfd\u0c00") + buf.write("\3\2\2\2\u0bfe\u0bfc\3\2\2\2\u0bff\u0bf6\3\2\2\2\u0bff") + buf.write("\u0c00\3\2\2\2\u0c00\u00e5\3\2\2\2\u0c01\u0c05\5\u00ea") + buf.write("v\2\u0c02\u0c05\5\u00ecw\2\u0c03\u0c05\5\u00eex\2\u0c04") + buf.write("\u0c01\3\2\2\2\u0c04\u0c02\3\2\2\2\u0c04\u0c03\3\2\2\2") + buf.write("\u0c05\u00e7\3\2\2\2\u0c06\u0c09\5\u00eav\2\u0c07\u0c09") + buf.write("\5\u00ecw\2\u0c08\u0c06\3\2\2\2\u0c08\u0c07\3\2\2\2\u0c09") + buf.write("\u00e9\3\2\2\2\u0c0a\u0c20\7\u0218\2\2\u0c0b\u0c20\7\u01fa") + buf.write("\2\2\u0c0c\u0c20\7\u01c8\2\2\u0c0d\u0c20\7\u01f5\2\2\u0c0e") + buf.write("\u0c20\7\u01c9\2\2\u0c0f\u0c20\7\u01f6\2\2\u0c10\u0c20") + buf.write("\7s\2\2\u0c11\u0c20\7\u01f7\2\2\u0c12\u0c20\7\u01e7\2") + buf.write("\2\u0c13\u0c20\7\u01f8\2\2\u0c14\u0c16\7M\2\2\u0c15\u0c14") + buf.write("\3\2\2\2\u0c15\u0c16\3\2\2\2\u0c16\u0c17\3\2\2\2\u0c17") + buf.write("\u0c1a\7\u00b0\2\2\u0c18\u0c1b\7\u0267\2\2\u0c19\u0c1b") + buf.write("\7\u01a1\2\2\u0c1a\u0c18\3\2\2\2\u0c1a\u0c19\3\2\2\2\u0c1b") + buf.write("\u0c20\3\2\2\2\u0c1c\u0c1d\7\u0114\2\2\u0c1d\u0c1e\7\u0111") + buf.write("\2\2\u0c1e\u0c20\7\u0267\2\2\u0c1f\u0c0a\3\2\2\2\u0c1f") + buf.write("\u0c0b\3\2\2\2\u0c1f\u0c0c\3\2\2\2\u0c1f\u0c0d\3\2\2\2") + buf.write("\u0c1f\u0c0e\3\2\2\2\u0c1f\u0c0f\3\2\2\2\u0c1f\u0c10\3") + buf.write("\2\2\2\u0c1f\u0c11\3\2\2\2\u0c1f\u0c12\3\2\2\2\u0c1f\u0c13") + buf.write("\3\2\2\2\u0c1f\u0c15\3\2\2\2\u0c1f\u0c1c\3\2\2\2\u0c20") + buf.write("\u00eb\3\2\2\2\u0c21\u0c29\7\u0206\2\2\u0c22\u0c29\7\u01f9") + buf.write("\2\2\u0c23\u0c29\7\u01c0\2\2\u0c24\u0c29\7\u01f4\2\2\u0c25") + buf.write("\u0c26\7*\2\2\u0c26\u0c27\7\u019d\2\2\u0c27\u0c29\5\u0150") + buf.write("\u00a9\2\u0c28\u0c21\3\2\2\2\u0c28\u0c22\3\2\2\2\u0c28") + buf.write("\u0c23\3\2\2\2\u0c28\u0c24\3\2\2\2\u0c28\u0c25\3\2\2\2") + buf.write("\u0c29\u00ed\3\2\2\2\u0c2a\u0c2b\7\u00fb\2\2\u0c2b\u0c37") + buf.write("\5\u0230\u0119\2\u0c2c\u0c2d\7\u0197\2\2\u0c2d\u0c34\7") + buf.write("\u00d3\2\2\u0c2e\u0c2f\7\u0197\2\2\u0c2f\u0c34\7\u0195") + buf.write("\2\2\u0c30\u0c34\7\u00d3\2\2\u0c31\u0c34\7\b\2\2\u0c32") + buf.write("\u0c34\7\u01b6\2\2\u0c33\u0c2c\3\2\2\2\u0c33\u0c2e\3\2") + buf.write("\2\2\u0c33\u0c30\3\2\2\2\u0c33\u0c31\3\2\2\2\u0c33\u0c32") + buf.write("\3\2\2\2\u0c34\u0c35\3\2\2\2\u0c35\u0c37\5\u02b6\u015c") + buf.write("\2\u0c36\u0c2a\3\2\2\2\u0c36\u0c33\3\2\2\2\u0c37\u00ef") + buf.write("\3\2\2\2\u0c38\u0c39\7\u0195\2\2\u0c39\u0c42\5\u0210\u0109") + buf.write("\2\u0c3a\u0c3c\7\u01bc\2\2\u0c3b\u0c3a\3\2\2\2\u0c3b\u0c3c") + buf.write("\3\2\2\2\u0c3c\u0c3e\3\2\2\2\u0c3d\u0c3f\5\u00f2z\2\u0c3e") + buf.write("\u0c3d\3\2\2\2\u0c3f\u0c40\3\2\2\2\u0c40\u0c3e\3\2\2\2") + buf.write("\u0c40\u0c41\3\2\2\2\u0c41\u0c43\3\2\2\2\u0c42\u0c3b\3") + buf.write("\2\2\2\u0c42\u0c43\3\2\2\2\u0c43\u00f1\3\2\2\2\u0c44\u0c47") + buf.write("\5\u00eav\2\u0c45\u0c47\5\u00eex\2\u0c46\u0c44\3\2\2\2") + buf.write("\u0c46\u0c45\3\2\2\2\u0c47\u00f3\3\2\2\2\u0c48\u0c49\7") + buf.write("\u00fe\2\2\u0c49\u0c4c\5\u0210\u0109\2\u0c4a\u0c4b\7\u00aa") + buf.write("\2\2\u0c4b\u0c4d\5,\27\2\u0c4c\u0c4a\3\2\2\2\u0c4c\u0c4d") + buf.write("\3\2\2\2\u0c4d\u0c4e\3\2\2\2\u0c4e\u0c4f\7\u0086\2\2\u0c4f") + buf.write("\u0c5c\7\u0267\2\2\u0c50\u0c51\7\u01bc\2\2\u0c51\u0c52") + buf.write("\7\u024b\2\2\u0c52\u0c57\5\u00a8U\2\u0c53\u0c54\7\u0245") + buf.write("\2\2\u0c54\u0c56\5\u00a8U\2\u0c55\u0c53\3\2\2\2\u0c56") + buf.write("\u0c59\3\2\2\2\u0c57\u0c55\3\2\2\2\u0c57\u0c58\3\2\2\2") + buf.write("\u0c58\u0c5a\3\2\2\2\u0c59\u0c57\3\2\2\2\u0c5a\u0c5b\7") + buf.write("\u024c\2\2\u0c5b\u0c5d\3\2\2\2\u0c5c\u0c50\3\2\2\2\u0c5c") + buf.write("\u0c5d\3\2\2\2\u0c5d\u00f5\3\2\2\2\u0c5e\u0c60\7\u00f2") + buf.write("\2\2\u0c5f\u0c61\5\u019a\u00ce\2\u0c60\u0c5f\3\2\2\2\u0c60") + buf.write("\u0c61\3\2\2\2\u0c61\u0c62\3\2\2\2\u0c62\u0c67\5\u026a") + buf.write("\u0136\2\u0c63\u0c64\7\u024b\2\2\u0c64\u0c65\5\u02b6\u015c") + buf.write("\2\u0c65\u0c66\7\u024c\2\2\u0c66\u0c68\3\2\2\2\u0c67\u0c63") + buf.write("\3\2\2\2\u0c67\u0c68\3\2\2\2\u0c68\u0c69\3\2\2\2\u0c69") + buf.write("\u0c6a\7\u01a3\2\2\u0c6a\u0c6b\5\u0210\u0109\2\u0c6b\u0c6c") + buf.write("\7\u0245\2\2\u0c6c\u0c6d\5\u02b6\u015c\2\u0c6d\u0c6e\7") + buf.write("\u0193\2\2\u0c6e\u0c6f\5\u026a\u0136\2\u0c6f\u00f7\3\2") + buf.write("\2\2\u0c70\u0c71\7\u0192\2\2\u0c71\u0c72\7\66\2\2\u0c72") + buf.write("\u0c73\7\u0121\2\2\u0c73\u0c78\5\u0210\u0109\2\u0c74\u0c75") + buf.write("\7d\2\2\u0c75\u0c79\5\u0220\u0111\2\u0c76\u0c77\7\u0098") + buf.write("\2\2\u0c77\u0c79\7d\2\2\u0c78\u0c74\3\2\2\2\u0c78\u0c76") + buf.write("\3\2\2\2\u0c78\u0c79\3\2\2\2\u0c79\u0c7e\3\2\2\2\u0c7a") + buf.write("\u0c7b\7\u0116\2\2\u0c7b\u0c7f\5\u0220\u0111\2\u0c7c\u0c7d") + buf.write("\7\u0098\2\2\u0c7d\u0c7f\7\u0116\2\2\u0c7e\u0c7a\3\2\2") + buf.write("\2\u0c7e\u0c7c\3\2\2\2\u0c7e\u0c7f\3\2\2\2\u0c7f\u0c8c") + buf.write("\3\2\2\2\u0c80\u0c81\7\u00a4\2\2\u0c81\u0c82\7\u024b\2") + buf.write("\2\u0c82\u0c87\5\u00fa~\2\u0c83\u0c84\7\u0245\2\2\u0c84") + buf.write("\u0c86\5\u00fa~\2\u0c85\u0c83\3\2\2\2\u0c86\u0c89\3\2") + buf.write("\2\2\u0c87\u0c85\3\2\2\2\u0c87\u0c88\3\2\2\2\u0c88\u0c8a") + buf.write("\3\2\2\2\u0c89\u0c87\3\2\2\2\u0c8a\u0c8b\7\u024c\2\2\u0c8b") + buf.write("\u0c8d\3\2\2\2\u0c8c\u0c80\3\2\2\2\u0c8c\u0c8d\3\2\2\2") + buf.write("\u0c8d\u00f9\3\2\2\2\u0c8e\u0c8f\5\u0210\u0109\2\u0c8f") + buf.write("\u0c90\7\u0267\2\2\u0c90\u00fb\3\2\2\2\u0c91\u0c92\7\u00a2") + buf.write("\2\2\u0c92\u0c93\5\u00fe\u0080\2\u0c93\u0c94\7\u024b\2") + buf.write("\2\u0c94\u0c99\5\u0100\u0081\2\u0c95\u0c96\7\u0245\2\2") + buf.write("\u0c96\u0c98\5\u0100\u0081\2\u0c97\u0c95\3\2\2\2\u0c98") + buf.write("\u0c9b\3\2\2\2\u0c99\u0c97\3\2\2\2\u0c99\u0c9a\3\2\2\2") + buf.write("\u0c9a\u0c9c\3\2\2\2\u0c9b\u0c99\3\2\2\2\u0c9c\u0c9d\7") + buf.write("\u024c\2\2\u0c9d\u00fd\3\2\2\2\u0c9e\u0c9f\5\u0210\u0109") + buf.write("\2\u0c9f\u0ca0\7\u0253\2\2\u0ca0\u0ca2\3\2\2\2\u0ca1\u0c9e") + buf.write("\3\2\2\2\u0ca1\u0ca2\3\2\2\2\u0ca2\u0ca3\3\2\2\2\u0ca3") + buf.write("\u0ca4\5\u01d2\u00ea\2\u0ca4\u00ff\3\2\2\2\u0ca5\u0ca6") + buf.write("\t\22\2\2\u0ca6\u0ca7\7\u0242\2\2\u0ca7\u0cb7\5\u026a") + buf.write("\u0136\2\u0ca8\u0ca9\7\u00d0\2\2\u0ca9\u0caa\7\u0242\2") + buf.write("\2\u0caa\u0cb7\5\u026a\u0136\2\u0cab\u0cac\7\u0165\2\2") + buf.write("\u0cac\u0cad\7\u0242\2\2\u0cad\u0cb7\5\u026a\u0136\2\u0cae") + buf.write("\u0caf\t&\2\2\u0caf\u0cb0\7\u0242\2\2\u0cb0\u0cb7\5\u0224") + buf.write("\u0113\2\u0cb1\u0cb2\t\'\2\2\u0cb2\u0cb3\7\u0242\2\2\u0cb3") + buf.write("\u0cb7\5\u0236\u011c\2\u0cb4\u0cb7\7\u01d8\2\2\u0cb5\u0cb7") + buf.write("\7\u01e9\2\2\u0cb6\u0ca5\3\2\2\2\u0cb6\u0ca8\3\2\2\2\u0cb6") + buf.write("\u0cab\3\2\2\2\u0cb6\u0cae\3\2\2\2\u0cb6\u0cb1\3\2\2\2") + buf.write("\u0cb6\u0cb4\3\2\2\2\u0cb6\u0cb5\3\2\2\2\u0cb7\u0101\3") + buf.write("\2\2\2\u0cb8\u0cb9\7\u01a5\2\2\u0cb9\u0cbb\7\u00cc\2\2") + buf.write("\u0cba\u0cb8\3\2\2\2\u0cba\u0cbb\3\2\2\2\u0cbb\u0cbc\3") + buf.write("\2\2\2\u0cbc\u0cbd\7\n\2\2\u0cbd\u0cbf\5\u026a\u0136\2") + buf.write("\u0cbe\u0cc0\5\u0142\u00a2\2\u0cbf\u0cbe\3\2\2\2\u0cbf") + buf.write("\u0cc0\3\2\2\2\u0cc0\u0cc1\3\2\2\2\u0cc1\u0cc7\7\u024b") + buf.write("\2\2\u0cc2\u0cc3\7\u01be\2\2\u0cc3\u0cc4\7\u0242\2\2\u0cc4") + buf.write("\u0cc5\5\u0224\u0113\2\u0cc5\u0cc6\7\u0245\2\2\u0cc6\u0cc8") + buf.write("\3\2\2\2\u0cc7\u0cc2\3\2\2\2\u0cc7\u0cc8\3\2\2\2\u0cc8") + buf.write("\u0cc9\3\2\2\2\u0cc9\u0cca\7\u020e\2\2\u0cca\u0ccb\7\u0242") + buf.write("\2\2\u0ccb\u0ccc\5\u026a\u0136\2\u0ccc\u0ccd\7\u0245\2") + buf.write("\2\u0ccd\u0cce\7\u0213\2\2\u0cce\u0ccf\7\u0242\2\2\u0ccf") + buf.write("\u0cd4\5\u0224\u0113\2\u0cd0\u0cd1\7\u0245\2\2\u0cd1\u0cd3") + buf.write("\5\u0104\u0083\2\u0cd2\u0cd0\3\2\2\2\u0cd3\u0cd6\3\2\2") + buf.write("\2\u0cd4\u0cd2\3\2\2\2\u0cd4\u0cd5\3\2\2\2\u0cd5\u0cd7") + buf.write("\3\2\2\2\u0cd6\u0cd4\3\2\2\2\u0cd7\u0cd8\7\u024c\2\2\u0cd8") + buf.write("\u0103\3\2\2\2\u0cd9\u0cda\7\u0212\2\2\u0cda\u0cdb\7\u0242") + buf.write("\2\2\u0cdb\u0d0d\7\u0262\2\2\u0cdc\u0cdd\7\u01cf\2\2\u0cdd") + buf.write("\u0cde\7\u0242\2\2\u0cde\u0d0d\5\u026a\u0136\2\u0cdf\u0d0d") + buf.write("\7\u01d0\2\2\u0ce0\u0ce1\7\u01d1\2\2\u0ce1\u0ce2\7\u0242") + buf.write("\2\2\u0ce2\u0d0d\t(\2\2\u0ce3\u0ce4\7\u01c4\2\2\u0ce4") + buf.write("\u0ce5\7\u0242\2\2\u0ce5\u0d0d\5\u026a\u0136\2\u0ce6\u0ce7") + buf.write("\7\u020c\2\2\u0ce7\u0ce8\7\u0242\2\2\u0ce8\u0d0d\5\u026a") + buf.write("\u0136\2\u0ce9\u0cea\7\u01ca\2\2\u0cea\u0ceb\7\u0242\2") + buf.write("\2\u0ceb\u0d0d\5\u026a\u0136\2\u0cec\u0ced\7\u01dd\2\2") + buf.write("\u0ced\u0cee\7\u0242\2\2\u0cee\u0d0d\5\u0230\u0119\2\u0cef") + buf.write("\u0cf0\7\u01f0\2\2\u0cf0\u0cf1\7\u0242\2\2\u0cf1\u0d0d") + buf.write("\5\u026a\u0136\2\u0cf2\u0cf3\7\u01ee\2\2\u0cf3\u0cf4\7") + buf.write("\u0242\2\2\u0cf4\u0d0d\5\u026a\u0136\2\u0cf5\u0cf6\7\u01f2") + buf.write("\2\2\u0cf6\u0cf7\7\u0242\2\2\u0cf7\u0d0d\5\u0224\u0113") + buf.write("\2\u0cf8\u0cf9\7\u01f1\2\2\u0cf9\u0cfa\7\u0242\2\2\u0cfa") + buf.write("\u0d0d\7\u0262\2\2\u0cfb\u0cfc\7\u01ea\2\2\u0cfc\u0cfd") + buf.write("\7\u0242\2\2\u0cfd\u0d0d\5\u026a\u0136\2\u0cfe\u0d0d\7") + buf.write("\u01eb\2\2\u0cff\u0d00\7\u01ec\2\2\u0d00\u0d01\7\u0242") + buf.write("\2\2\u0d01\u0d0d\t(\2\2\u0d02\u0d03\7\u01ed\2\2\u0d03") + buf.write("\u0d04\7\u0242\2\2\u0d04\u0d0d\5\u0230\u0119\2\u0d05\u0d06") + buf.write("\7\u0211\2\2\u0d06\u0d07\7\u0242\2\2\u0d07\u0d0d\5\u0236") + buf.write("\u011c\2\u0d08\u0d09\7\u00ab\2\2\u0d09\u0d0a\7\u0242\2") + buf.write("\2\u0d0a\u0d0d\t\33\2\2\u0d0b\u0d0d\7\u01da\2\2\u0d0c") + buf.write("\u0cd9\3\2\2\2\u0d0c\u0cdc\3\2\2\2\u0d0c\u0cdf\3\2\2\2") + buf.write("\u0d0c\u0ce0\3\2\2\2\u0d0c\u0ce3\3\2\2\2\u0d0c\u0ce6\3") + buf.write("\2\2\2\u0d0c\u0ce9\3\2\2\2\u0d0c\u0cec\3\2\2\2\u0d0c\u0cef") + buf.write("\3\2\2\2\u0d0c\u0cf2\3\2\2\2\u0d0c\u0cf5\3\2\2\2\u0d0c") + buf.write("\u0cf8\3\2\2\2\u0d0c\u0cfb\3\2\2\2\u0d0c\u0cfe\3\2\2\2") + buf.write("\u0d0c\u0cff\3\2\2\2\u0d0c\u0d02\3\2\2\2\u0d0c\u0d05\3") + buf.write("\2\2\2\u0d0c\u0d08\3\2\2\2\u0d0c\u0d0b\3\2\2\2\u0d0d\u0105") + buf.write("\3\2\2\2\u0d0e\u0d0f\7\u00e6\2\2\u0d0f\u0d10\5\u0108\u0085") + buf.write("\2\u0d10\u0107\3\2\2\2\u0d11\u0d14\7+\2\2\u0d12\u0d15") + buf.write("\7\u0170\2\2\u0d13\u0d15\5\u01da\u00ee\2\u0d14\u0d12\3") + buf.write("\2\2\2\u0d14\u0d13\3\2\2\2\u0d15\u0d16\3\2\2\2\u0d16\u0d37") + buf.write("\t\31\2\2\u0d17\u0d18\7\u0104\2\2\u0d18\u0d1d\5\26\f\2") + buf.write("\u0d19\u0d1a\7\u0245\2\2\u0d1a\u0d1c\5\26\f\2\u0d1b\u0d19") + buf.write("\3\2\2\2\u0d1c\u0d1f\3\2\2\2\u0d1d\u0d1b\3\2\2\2\u0d1d") + buf.write("\u0d1e\3\2\2\2\u0d1e\u0d37\3\2\2\2\u0d1f\u0d1d\3\2\2\2") + buf.write("\u0d20\u0d21\7\u0104\2\2\u0d21\u0d22\7\u00ec\2\2\u0d22") + buf.write("\u0d37\7\u0267\2\2\u0d23\u0d24\7\u00e5\2\2\u0d24\u0d25") + buf.write("\7\36\2\2\u0d25\u0d26\7\u0176\2\2\u0d26\u0d27\7\u0104") + buf.write("\2\2\u0d27\u0d2c\5\26\f\2\u0d28\u0d29\7\u0245\2\2\u0d29") + buf.write("\u0d2b\5\26\f\2\u0d2a\u0d28\3\2\2\2\u0d2b\u0d2e\3\2\2") + buf.write("\2\u0d2c\u0d2a\3\2\2\2\u0d2c\u0d2d\3\2\2\2\u0d2d\u0d37") + buf.write("\3\2\2\2\u0d2e\u0d2c\3\2\2\2\u0d2f\u0d31\t)\2\2\u0d30") + buf.write("\u0d2f\3\2\2\2\u0d30\u0d31\3\2\2\2\u0d31\u0d32\3\2\2\2") + buf.write("\u0d32\u0d37\5\u010a\u0086\2\u0d33\u0d34\7\u0123\2\2\u0d34") + buf.write("\u0d35\7\u00a3\2\2\u0d35\u0d37\t*\2\2\u0d36\u0d11\3\2") + buf.write("\2\2\u0d36\u0d17\3\2\2\2\u0d36\u0d20\3\2\2\2\u0d36\u0d23") + buf.write("\3\2\2\2\u0d36\u0d30\3\2\2\2\u0d36\u0d33\3\2\2\2\u0d37") + buf.write("\u0109\3\2\2\2\u0d38\u0d39\7\u00e5\2\2\u0d39\u0d3d\7\u0159") + buf.write("\2\2\u0d3a\u0d3e\7\u0267\2\2\u0d3b\u0d3e\5\u0210\u0109") + buf.write("\2\u0d3c\u0d3e\7\u0187\2\2\u0d3d\u0d3a\3\2\2\2\u0d3d\u0d3b") + buf.write("\3\2\2\2\u0d3d\u0d3c\3\2\2\2\u0d3e\u0d56\3\2\2\2\u0d3f") + buf.write("\u0d40\7\u0148\2\2\u0d40\u0d45\7\u0126\2\2\u0d41\u0d46") + buf.write("\7\u0267\2\2\u0d42\u0d46\5\u0152\u00aa\2\u0d43\u0d46\7") + buf.write("\u0085\2\2\u0d44\u0d46\7\u0187\2\2\u0d45\u0d41\3\2\2\2") + buf.write("\u0d45\u0d42\3\2\2\2\u0d45\u0d43\3\2\2\2\u0d45\u0d44\3") + buf.write("\2\2\2\u0d46\u0d56\3\2\2\2\u0d47\u0d48\5\u0210\u0109\2") + buf.write("\u0d48\u0d49\7\u0253\2\2\u0d49\u0d4b\3\2\2\2\u0d4a\u0d47") + buf.write("\3\2\2\2\u0d4a\u0d4b\3\2\2\2\u0d4b\u0d4c\3\2\2\2\u0d4c") + buf.write("\u0d4d\5\u0210\u0109\2\u0d4d\u0d4e\t\34\2\2\u0d4e\u0d4f") + buf.write("\5\u010c\u0087\2\u0d4f\u0d56\3\2\2\2\u0d50\u0d53\7\u00d3") + buf.write("\2\2\u0d51\u0d54\5\u0210\u0109\2\u0d52\u0d54\7\u013c\2") + buf.write("\2\u0d53\u0d51\3\2\2\2\u0d53\u0d52\3\2\2\2\u0d54\u0d56") + buf.write("\3\2\2\2\u0d55\u0d38\3\2\2\2\u0d55\u0d3f\3\2\2\2\u0d55") + buf.write("\u0d4a\3\2\2\2\u0d55\u0d50\3\2\2\2\u0d56\u010b\3\2\2\2") + buf.write("\u0d57\u0d5c\5\u0230\u0119\2\u0d58\u0d59\7\u0245\2\2\u0d59") + buf.write("\u0d5b\5\u0230\u0119\2\u0d5a\u0d58\3\2\2\2\u0d5b\u0d5e") + buf.write("\3\2\2\2\u0d5c\u0d5a\3\2\2\2\u0d5c\u0d5d\3\2\2\2\u0d5d") + buf.write("\u0d61\3\2\2\2\u0d5e\u0d5c\3\2\2\2\u0d5f\u0d61\7\u0187") + buf.write("\2\2\u0d60\u0d57\3\2\2\2\u0d60\u0d5f\3\2\2\2\u0d61\u010d") + buf.write("\3\2\2\2\u0d62\u0d63\7\u01a5\2\2\u0d63\u0d65\7\u00cc\2") + buf.write("\2\u0d64\u0d62\3\2\2\2\u0d64\u0d65\3\2\2\2\u0d65\u0d66") + buf.write("\3\2\2\2\u0d66\u0d67\7\u00d9\2\2\u0d67\u0d68\5\u0210\u0109") + buf.write("\2\u0d68\u0d69\7\u0176\2\2\u0d69\u0d6a\7\u01a3\2\2\u0d6a") + buf.write("\u0d6b\t+\2\2\u0d6b\u0d6c\7\u01b1\2\2\u0d6c\u0d6f\5\u026a") + buf.write("\u0136\2\u0d6d\u0d6e\7\u01ba\2\2\u0d6e\u0d70\5\u0230\u0119") + buf.write("\2\u0d6f\u0d6d\3\2\2\2\u0d6f\u0d70\3\2\2\2\u0d70\u0d71") + buf.write("\3\2\2\2\u0d71\u0d73\7\u018b\2\2\u0d72\u0d74\t,\2\2\u0d73") + buf.write("\u0d72\3\2\2\2\u0d73\u0d74\3\2\2\2\u0d74\u0d86\3\2\2\2") + buf.write("\u0d75\u0d87\7\u0099\2\2\u0d76\u0d87\5\u0110\u0089\2\u0d77") + buf.write("\u0d7d\7\u024b\2\2\u0d78\u0d79\5\u0110\u0089\2\u0d79\u0d7a") + buf.write("\7\u0244\2\2\u0d7a\u0d7c\3\2\2\2\u0d7b\u0d78\3\2\2\2\u0d7c") + buf.write("\u0d7f\3\2\2\2\u0d7d\u0d7b\3\2\2\2\u0d7d\u0d7e\3\2\2\2") + buf.write("\u0d7e\u0d80\3\2\2\2\u0d7f\u0d7d\3\2\2\2\u0d80\u0d82\5") + buf.write("\u0110\u0089\2\u0d81\u0d83\7\u0244\2\2\u0d82\u0d81\3\2") + buf.write("\2\2\u0d82\u0d83\3\2\2\2\u0d83\u0d84\3\2\2\2\u0d84\u0d85") + buf.write("\7\u024c\2\2\u0d85\u0d87\3\2\2\2\u0d86\u0d75\3\2\2\2\u0d86") + buf.write("\u0d76\3\2\2\2\u0d86\u0d77\3\2\2\2\u0d87\u010f\3\2\2\2") + buf.write("\u0d88\u0d8e\5\u0270\u0139\2\u0d89\u0d8e\5\u02a2\u0152") + buf.write("\2\u0d8a\u0d8e\5\u02ae\u0158\2\u0d8b\u0d8e\5\u02ac\u0157") + buf.write("\2\u0d8c\u0d8e\5\u02b2\u015a\2\u0d8d\u0d88\3\2\2\2\u0d8d") + buf.write("\u0d89\3\2\2\2\u0d8d\u0d8a\3\2\2\2\u0d8d\u0d8b\3\2\2\2") + buf.write("\u0d8d\u0d8c\3\2\2\2\u0d8e\u0111\3\2\2\2\u0d8f\u0d91\7") + buf.write("\u017f\2\2\u0d90\u0d8f\3\2\2\2\u0d90\u0d91\3\2\2\2\u0d91") + buf.write("\u0d92\3\2\2\2\u0d92\u0d93\7\u0106\2\2\u0d93\u0d98\5\u0210") + buf.write("\u0109\2\u0d94\u0d99\7\24\2\2\u0d95\u0d96\7y\2\2\u0d96") + buf.write("\u0d99\7\u009e\2\2\u0d97\u0d99\7\t\2\2\u0d98\u0d94\3\2") + buf.write("\2\2\u0d98\u0d95\3\2\2\2\u0d98\u0d97\3\2\2\2\u0d99\u0da9") + buf.write("\3\2\2\2\u0d9a\u0d9e\7x\2\2\u0d9b\u0d9e\7>\2\2\u0d9c\u0d9e") + buf.write("\7\u0107\2\2\u0d9d\u0d9a\3\2\2\2\u0d9d\u0d9b\3\2\2\2\u0d9d") + buf.write("\u0d9c\3\2\2\2\u0d9e\u0da5\3\2\2\2\u0d9f\u0da2\7\u0112") + buf.write("\2\2\u0da0\u0da1\7\u009e\2\2\u0da1\u0da3\5\u02b6\u015c") + buf.write("\2\u0da2\u0da0\3\2\2\2\u0da2\u0da3\3\2\2\2\u0da3\u0da5") + buf.write("\3\2\2\2\u0da4\u0d9d\3\2\2\2\u0da4\u0d9f\3\2\2\2\u0da5") + buf.write("\u0da7\3\2\2\2\u0da6\u0da8\7\u01a5\2\2\u0da7\u0da6\3\2") + buf.write("\2\2\u0da7\u0da8\3\2\2\2\u0da8\u0daa\3\2\2\2\u0da9\u0da4") + buf.write("\3\2\2\2\u0daa\u0dab\3\2\2\2\u0dab\u0da9\3\2\2\2\u0dab") + buf.write("\u0dac\3\2\2\2\u0dac\u0dad\3\2\2\2\u0dad\u0dae\7\u01a3") + buf.write("\2\2\u0dae\u0db1\5\u026a\u0136\2\u0daf\u0db0\7\u0193\2") + buf.write("\2\u0db0\u0db2\5\u026a\u0136\2\u0db1\u0daf\3\2\2\2\u0db1") + buf.write("\u0db2\3\2\2\2\u0db2\u0db4\3\2\2\2\u0db3\u0db5\5d\63\2") + buf.write("\u0db4\u0db3\3\2\2\2\u0db4\u0db5\3\2\2\2\u0db5\u0db7\3") + buf.write("\2\2\2\u0db6\u0db8\5f\64\2\u0db7\u0db6\3\2\2\2\u0db7\u0db8") + buf.write("\3\2\2\2\u0db8\u0dbe\3\2\2\2\u0db9\u0dba\7\u00c5\2\2\u0dba") + buf.write("\u0dbc\5\u0114\u008b\2\u0dbb\u0dbd\5\u0114\u008b\2\u0dbc") + buf.write("\u0dbb\3\2\2\2\u0dbc\u0dbd\3\2\2\2\u0dbd\u0dbf\3\2\2\2") + buf.write("\u0dbe\u0db9\3\2\2\2\u0dbe\u0dbf\3\2\2\2\u0dbf\u0dc5\3") + buf.write("\2\2\2\u0dc0\u0dc2\7\u0191\2\2\u0dc1\u0dc3\7J\2\2\u0dc2") + buf.write("\u0dc1\3\2\2\2\u0dc2\u0dc3\3\2\2\2\u0dc3\u0dc4\3\2\2\2") + buf.write("\u0dc4\u0dc6\t-\2\2\u0dc5\u0dc0\3\2\2\2\u0dc5\u0dc6\3") + buf.write("\2\2\2\u0dc6\u0dc8\3\2\2\2\u0dc7\u0dc9\5\u0116\u008c\2") + buf.write("\u0dc8\u0dc7\3\2\2\2\u0dc8\u0dc9\3\2\2\2\u0dc9\u0dca\3") + buf.write("\2\2\2\u0dca\u0dcb\7T\2\2\u0dcb\u0dcc\t\22\2\2\u0dcc\u0dcd") + buf.write("\5\u0246\u0124\2\u0dcd\u0113\3\2\2\2\u0dce\u0dcf\t.\2") + buf.write("\2\u0dcf\u0dd1\7\u01af\2\2\u0dd0\u0dd2\7\u0176\2\2\u0dd1") + buf.write("\u0dd0\3\2\2\2\u0dd1\u0dd2\3\2\2\2\u0dd2\u0dd3\3\2\2\2") + buf.write("\u0dd3\u0dd4\5\u0210\u0109\2\u0dd4\u0115\3\2\2\2\u0dd5") + buf.write("\u0dd6\7\u01b9\2\2\u0dd6\u0dd7\7\u024b\2\2\u0dd7\u0dd8") + buf.write("\5\u0230\u0119\2\u0dd8\u0dd9\7\u024c\2\2\u0dd9\u0117\3") + buf.write("\2\2\2\u0dda\u0de0\7\u0194\2\2\u0ddb\u0ddd\7\u00d2\2\2") + buf.write("\u0ddc\u0dde\5t;\2\u0ddd\u0ddc\3\2\2\2\u0ddd\u0dde\3\2") + buf.write("\2\2\u0dde\u0de0\3\2\2\2\u0ddf\u0dda\3\2\2\2\u0ddf\u0ddb") + buf.write("\3\2\2\2\u0de0\u0de3\3\2\2\2\u0de1\u0de4\5\u0120\u0091") + buf.write("\2\u0de2\u0de4\5\u011c\u008f\2\u0de3\u0de1\3\2\2\2\u0de3") + buf.write("\u0de2\3\2\2\2\u0de4\u0de5\3\2\2\2\u0de5\u0de6\7\u01a3") + buf.write("\2\2\u0de6\u0de7\5\u011a\u008e\2\u0de7\u0de8\t/\2\2\u0de8") + buf.write("\u0ded\5\u012a\u0096\2\u0de9\u0dea\7\u01bc\2\2\u0dea\u0deb") + buf.write("\7\u0194\2\2\u0deb\u0dee\7\u00a3\2\2\u0dec\u0dee\5\u01f8") + buf.write("\u00fd\2\u0ded\u0de9\3\2\2\2\u0ded\u0dec\3\2\2\2\u0ded") + buf.write("\u0dee\3\2\2\2\u0dee\u0df1\3\2\2\2\u0def\u0df1\5\u0124") + buf.write("\u0093\2\u0df0\u0ddf\3\2\2\2\u0df0\u0def\3\2\2\2\u0df1") + buf.write("\u0119\3\2\2\2\u0df2\u0df4\7\u01af\2\2\u0df3\u0df2\3\2") + buf.write("\2\2\u0df3\u0df4\3\2\2\2\u0df4\u0df5\3\2\2\2\u0df5\u0e24") + buf.write("\5\u01da\u00ee\2\u0df6\u0df7\7\u00e1\2\2\u0df7\u0e24\5") + buf.write("\u01da\u00ee\2\u0df8\u0df9\7\67\2\2\u0df9\u0e24\5\u01da") + buf.write("\u00ee\2\u0dfa\u0dfb\7G\2\2\u0dfb\u0e24\5\u01da\u00ee") + buf.write("\2\u0dfc\u0dfd\7\u0192\2\2\u0dfd\u0dfe\7\66\2\2\u0dfe") + buf.write("\u0dff\7\u0121\2\2\u0dff\u0e24\5\u01da\u00ee\2\u0e00\u0e01") + buf.write("\7\u0192\2\2\u0e01\u0e02\7\u00e4\2\2\u0e02\u0e24\5\u01da") + buf.write("\u00ee\2\u0e03\u0e04\t\60\2\2\u0e04\u0e09\5\u0140\u00a1") + buf.write("\2\u0e05\u0e06\7\u0245\2\2\u0e06\u0e08\5\u0140\u00a1\2") + buf.write("\u0e07\u0e05\3\2\2\2\u0e08\u0e0b\3\2\2\2\u0e09\u0e07\3") + buf.write("\2\2\2\u0e09\u0e0a\3\2\2\2\u0e0a\u0e24\3\2\2\2\u0e0b\u0e09") + buf.write("\3\2\2\2\u0e0c\u0e0d\7\177\2\2\u0e0d\u0e0e\7\u009d\2\2") + buf.write("\u0e0e\u0e13\7\u0262\2\2\u0e0f\u0e10\7\u0245\2\2\u0e10") + buf.write("\u0e12\7\u0262\2\2\u0e11\u0e0f\3\2\2\2\u0e12\u0e15\3\2") + buf.write("\2\2\u0e13\u0e11\3\2\2\2\u0e13\u0e14\3\2\2\2\u0e14\u0e24") + buf.write("\3\2\2\2\u0e15\u0e13\3\2\2\2\u0e16\u0e17\7~\2\2\u0e17") + buf.write("\u0e24\5\u01da\u00ee\2\u0e18\u0e19\7\u00db\2\2\u0e19\u0e24") + buf.write("\5\u01da\u00ee\2\u0e1a\u0e1b\7\u00fe\2\2\u0e1b\u0e24\5") + buf.write("\u01da\u00ee\2\u0e1c\u0e1d\7\u0109\2\2\u0e1d\u0e24\5\u01da") + buf.write("\u00ee\2\u0e1e\u0e1f\7\u0170\2\2\u0e1f\u0e20\t\61\2\2") + buf.write("\u0e20\u0e21\7\u0197\2\2\u0e21\u0e22\7\u00db\2\2\u0e22") + buf.write("\u0e24\5\u01da\u00ee\2\u0e23\u0df3\3\2\2\2\u0e23\u0df6") + buf.write("\3\2\2\2\u0e23\u0df8\3\2\2\2\u0e23\u0dfa\3\2\2\2\u0e23") + buf.write("\u0dfc\3\2\2\2\u0e23\u0e00\3\2\2\2\u0e23\u0e03\3\2\2\2") + buf.write("\u0e23\u0e0c\3\2\2\2\u0e23\u0e16\3\2\2\2\u0e23\u0e18\3") + buf.write("\2\2\2\u0e23\u0e1a\3\2\2\2\u0e23\u0e1c\3\2\2\2\u0e23\u0e1e") + buf.write("\3\2\2\2\u0e24\u011b\3\2\2\2\u0e25\u0e2a\5\u011e\u0090") + buf.write("\2\u0e26\u0e27\7\u0245\2\2\u0e27\u0e29\5\u011e\u0090\2") + buf.write("\u0e28\u0e26\3\2\2\2\u0e29\u0e2c\3\2\2\2\u0e2a\u0e28\3") + buf.write("\2\2\2\u0e2a\u0e2b\3\2\2\2\u0e2b\u011d\3\2\2\2\u0e2c\u0e2a") + buf.write("\3\2\2\2\u0e2d\u0e2e\5\u01f2\u00fa\2\u0e2e\u0e2f\7\u024b") + buf.write("\2\2\u0e2f\u0e30\5\u02b6\u015c\2\u0e30\u0e31\7\u024c\2") + buf.write("\2\u0e31\u011f\3\2\2\2\u0e32\u0e37\5\u0122\u0092\2\u0e33") + buf.write("\u0e34\7\u0245\2\2\u0e34\u0e36\5\u0122\u0092\2\u0e35\u0e33") + buf.write("\3\2\2\2\u0e36\u0e39\3\2\2\2\u0e37\u0e35\3\2\2\2\u0e37") + buf.write("\u0e38\3\2\2\2\u0e38\u0121\3\2\2\2\u0e39\u0e37\3\2\2\2") + buf.write("\u0e3a\u0e3c\7\u0170\2\2\u0e3b\u0e3d\7\u00b8\2\2\u0e3c") + buf.write("\u0e3b\3\2\2\2\u0e3c\u0e3d\3\2\2\2\u0e3d\u0e4b\3\2\2\2") + buf.write("\u0e3e\u0e4b\7\u01c6\2\2\u0e3f\u0e4b\7\u0180\2\2\u0e40") + buf.write("\u0e4b\7>\2\2\u0e41\u0e4b\7T\2\2\u0e42\u0e4b\7x\2\2\u0e43") + buf.write("\u0e4b\7\u0112\2\2\u0e44\u0e4b\7\u01a9\2\2\u0e45\u0e4b") + buf.write("\7\u01ab\2\2\u0e46\u0e4b\7\u00ff\2\2\u0e47\u0e4b\7\u0106") + buf.write("\2\2\u0e48\u0e4b\7\u0107\2\2\u0e49\u0e4b\7\u021d\2\2\u0e4a") + buf.write("\u0e3a\3\2\2\2\u0e4a\u0e3e\3\2\2\2\u0e4a\u0e3f\3\2\2\2") + buf.write("\u0e4a\u0e40\3\2\2\2\u0e4a\u0e41\3\2\2\2\u0e4a\u0e42\3") + buf.write("\2\2\2\u0e4a\u0e43\3\2\2\2\u0e4a\u0e44\3\2\2\2\u0e4a\u0e45") + buf.write("\3\2\2\2\u0e4a\u0e46\3\2\2\2\u0e4a\u0e47\3\2\2\2\u0e4a") + buf.write("\u0e48\3\2\2\2\u0e4a\u0e49\3\2\2\2\u0e4b\u0123\3\2\2\2") + buf.write("\u0e4c\u0e4d\7\u0194\2\2\u0e4d\u0e4e\5\u01da\u00ee\2\u0e4e") + buf.write("\u0e4f\7\u01b1\2\2\u0e4f\u0e53\5\u01da\u00ee\2\u0e50\u0e51") + buf.write("\7\u01bc\2\2\u0e51\u0e52\7\b\2\2\u0e52\u0e54\7\u00a3\2") + buf.write("\2\u0e53\u0e50\3\2\2\2\u0e53\u0e54\3\2\2\2\u0e54\u0e62") + buf.write("\3\2\2\2\u0e55\u0e59\7\u00d2\2\2\u0e56\u0e57\7\b\2\2\u0e57") + buf.write("\u0e58\7\u00a3\2\2\u0e58\u0e5a\7\u0191\2\2\u0e59\u0e56") + buf.write("\3\2\2\2\u0e59\u0e5a\3\2\2\2\u0e5a\u0e5b\3\2\2\2\u0e5b") + buf.write("\u0e5c\5\u01da\u00ee\2\u0e5c\u0e5d\7\u0193\2\2\u0e5d\u0e5f") + buf.write("\5\u01da\u00ee\2\u0e5e\u0e60\5\u01f8\u00fd\2\u0e5f\u0e5e") + buf.write("\3\2\2\2\u0e5f\u0e60\3\2\2\2\u0e60\u0e62\3\2\2\2\u0e61") + buf.write("\u0e4c\3\2\2\2\u0e61\u0e55\3\2\2\2\u0e62\u0125\3\2\2\2") + buf.write("\u0e63\u0e64\7\u01b1\2\2\u0e64\u0e68\5\u012a\u0096\2\u0e65") + buf.write("\u0e66\7\u01bc\2\2\u0e66\u0e67\7\u0194\2\2\u0e67\u0e69") + buf.write("\7\u00a3\2\2\u0e68\u0e65\3\2\2\2\u0e68\u0e69\3\2\2\2\u0e69") + buf.write("\u0127\3\2\2\2\u0e6a\u0e6b\7\u0193\2\2\u0e6b\u0e6d\5\u012a") + buf.write("\u0096\2\u0e6c\u0e6e\5\u01f8\u00fd\2\u0e6d\u0e6c\3\2\2") + buf.write("\2\u0e6d\u0e6e\3\2\2\2\u0e6e\u0129\3\2\2\2\u0e6f\u0e74") + buf.write("\5\u012c\u0097\2\u0e70\u0e71\7\u0245\2\2\u0e71\u0e73\5") + buf.write("\u012c\u0097\2\u0e72\u0e70\3\2\2\2\u0e73\u0e76\3\2\2\2") + buf.write("\u0e74\u0e72\3\2\2\2\u0e74\u0e75\3\2\2\2\u0e75\u012b\3") + buf.write("\2\2\2\u0e76\u0e74\3\2\2\2\u0e77\u0e79\7\u0195\2\2\u0e78") + buf.write("\u0e77\3\2\2\2\u0e78\u0e79\3\2\2\2\u0e79\u0e7a\3\2\2\2") + buf.write("\u0e7a\u0e7b\5,\27\2\u0e7b\u012d\3\2\2\2\u0e7c\u0e7d\7") + buf.write("$\2\2\u0e7d\u0e7e\7\u01a3\2\2\u0e7e\u0e7f\5\u0132\u009a") + buf.write("\2\u0e7f\u0e82\7\u0163\2\2\u0e80\u0e83\5\u0146\u00a4\2") + buf.write("\u0e81\u0e83\7\u01a1\2\2\u0e82\u0e80\3\2\2\2\u0e82\u0e81") + buf.write("\3\2\2\2\u0e83\u012f\3\2\2\2\u0e84\u0e85\7\u00e0\2\2\u0e85") + buf.write("\u0e8b\7}\2\2\u0e86\u0e89\7\u0191\2\2\u0e87\u0e8a\5\u0210") + buf.write("\u0109\2\u0e88\u0e8a\5\u0146\u00a4\2\u0e89\u0e87\3\2\2") + buf.write("\2\u0e89\u0e88\3\2\2\2\u0e8a\u0e8c\3\2\2\2\u0e8b\u0e86") + buf.write("\3\2\2\2\u0e8b\u0e8c\3\2\2\2\u0e8c\u0e8d\3\2\2\2\u0e8d") + buf.write("\u0e8e\7\u01a3\2\2\u0e8e\u0e8f\5\u0134\u009b\2\u0e8f\u0e92") + buf.write("\7\u0163\2\2\u0e90\u0e93\5\u0146\u00a4\2\u0e91\u0e93\7") + buf.write("\u01a1\2\2\u0e92\u0e90\3\2\2\2\u0e92\u0e91\3\2\2\2\u0e93") + buf.write("\u0131\3\2\2\2\u0e94\u0e95\7\5\2\2\u0e95\u0e96\7\u008e") + buf.write("\2\2\u0e96\u0f11\5\u0210\u0109\2\u0e97\u0e98\t\62\2\2") + buf.write("\u0e98\u0e99\5\u026a\u0136\2\u0e99\u0e9a\5\u0142\u00a2") + buf.write("\2\u0e9a\u0f11\3\2\2\2\u0e9b\u0e9c\7\u017b\2\2\u0e9c\u0e9d") + buf.write("\7\u024b\2\2\u0e9d\u0e9e\5\u0224\u0113\2\u0e9e\u0e9f\7") + buf.write("\u0176\2\2\u0e9f\u0ea0\5\u0224\u0113\2\u0ea0\u0ea1\7\u024c") + buf.write("\2\2\u0ea1\u0f11\3\2\2\2\u0ea2\u0ea3\7\u015b\2\2\u0ea3") + buf.write("\u0f11\5\u0210\u0109\2\u0ea4\u0ea5\7\u017e\2\2\u0ea5\u0f11") + buf.write("\5\u026a\u0136\2\u0ea6\u0ea7\7\u017f\2\2\u0ea7\u0ea8\5") + buf.write("\u0210\u0109\2\u0ea8\u0eaa\7\u01a3\2\2\u0ea9\u0eab\7G") + buf.write("\2\2\u0eaa\u0ea9\3\2\2\2\u0eaa\u0eab\3\2\2\2\u0eab\u0eac") + buf.write("\3\2\2\2\u0eac\u0ead\5\u026a\u0136\2\u0ead\u0f11\3\2\2") + buf.write("\2\u0eae\u0eaf\7.\2\2\u0eaf\u0f11\5\u026a\u0136\2\u0eb0") + buf.write("\u0eb1\7\67\2\2\u0eb1\u0f11\5\u0210\u0109\2\u0eb2\u0eb3") + buf.write("\7G\2\2\u0eb3\u0f11\5\u026a\u0136\2\u0eb4\u0eb5\7V\2\2") + buf.write("\u0eb5\u0f11\5\u0210\u0109\2\u0eb6\u0eb7\7P\2\2\u0eb7") + buf.write("\u0eb8\7\u0106\2\2\u0eb8\u0f11\5\u0210\u0109\2\u0eb9\u0eba") + buf.write("\7\u0192\2\2\u0eba\u0ebb\7\66\2\2\u0ebb\u0ebc\7\u0121") + buf.write("\2\2\u0ebc\u0f11\5\u0210\u0109\2\u0ebd\u0ebf\7\u0192\2") + buf.write("\2\u0ebe\u0ebd\3\2\2\2\u0ebe\u0ebf\3\2\2\2\u0ebf\u0ec0") + buf.write("\3\2\2\2\u0ec0\u0ec1\7\u01af\2\2\u0ec1\u0f11\5\u026a\u0136") + buf.write("\2\u0ec2\u0ec3\7q\2\2\u0ec3\u0f11\5\u026a\u0136\2\u0ec4") + buf.write("\u0ec5\7\177\2\2\u0ec5\u0ec6\7\u009d\2\2\u0ec6\u0f11\7") + buf.write("\u0262\2\2\u0ec7\u0ec9\7\u008c\2\2\u0ec8\u0ec7\3\2\2\2") + buf.write("\u0ec8\u0ec9\3\2\2\2\u0ec9\u0eca\3\2\2\2\u0eca\u0ecb\7") + buf.write("\u011a\2\2\u0ecb\u0f11\5\u026a\u0136\2\u0ecc\u0ecd\7\u00a2") + buf.write("\2\2\u0ecd\u0f11\5\u00dco\2\u0ece\u0ecf\7\u00a2\2\2\u0ecf") + buf.write("\u0ed0\t\63\2\2\u0ed0\u0ed1\5\u026a\u0136\2\u0ed1\u0ed2") + buf.write("\7\u01b7\2\2\u0ed2\u0ed3\5\u0210\u0109\2\u0ed3\u0f11\3") + buf.write("\2\2\2\u0ed4\u0ed5\7\u00b2\2\2\u0ed5\u0ed6\5\u0210\u0109") + buf.write("\2\u0ed6\u0ed7\7\u01a3\2\2\u0ed7\u0ed8\5\u026a\u0136\2") + buf.write("\u0ed8\u0f11\3\2\2\2\u0ed9\u0edb\7\u00b9\2\2\u0eda\u0ed9") + buf.write("\3\2\2\2\u0eda\u0edb\3\2\2\2\u0edb\u0edc\3\2\2\2\u0edc") + buf.write("\u0edd\7~\2\2\u0edd\u0f11\5\u026a\u0136\2\u0ede\u0edf") + buf.write("\7\u00bd\2\2\u0edf\u0f11\5\u0210\u0109\2\u0ee0\u0ee1\7") + buf.write("\u00d3\2\2\u0ee1\u0f11\5\u0210\u0109\2\u0ee2\u0ee3\7\u00d9") + buf.write("\2\2\u0ee3\u0ee4\5\u0210\u0109\2\u0ee4\u0ee5\7\u01a3\2") + buf.write("\2\u0ee5\u0ee6\5\u026a\u0136\2\u0ee6\u0f11\3\2\2\2\u0ee7") + buf.write("\u0ee8\7\u00db\2\2\u0ee8\u0f11\5\u0210\u0109\2\u0ee9\u0eea") + buf.write("\7\u00e1\2\2\u0eea\u0f11\5\u026a\u0136\2\u0eeb\u0eec\7") + buf.write("\u00e4\2\2\u0eec\u0f11\5\u0210\u0109\2\u0eed\u0eee\7\u00f2") + buf.write("\2\2\u0eee\u0f11\5\u026a\u0136\2\u0eef\u0ef0\7\u00f9\2") + buf.write("\2\u0ef0\u0f11\5\u0210\u0109\2\u0ef1\u0ef2\7\u00fe\2\2") + buf.write("\u0ef2\u0f11\5\u0210\u0109\2\u0ef3\u0ef4\7\u0102\2\2\u0ef4") + buf.write("\u0ef5\7\u00de\2\2\u0ef5\u0ef6\7(\2\2\u0ef6\u0f11\5\u026a") + buf.write("\u0136\2\u0ef7\u0ef8\7\u0102\2\2\u0ef8\u0ef9\7\u00de\2") + buf.write("\2\u0ef9\u0efa\7C\2\2\u0efa\u0f11\5\u026a\u0136\2\u0efb") + buf.write("\u0efc\7\u0102\2\2\u0efc\u0efd\7\u00de\2\2\u0efd\u0efe") + buf.write("\7\u00ac\2\2\u0efe\u0f11\5\u026a\u0136\2\u0eff\u0f00\7") + buf.write("\u0102\2\2\u0f00\u0f01\7\u00de\2\2\u0f01\u0f02\7\u0100") + buf.write("\2\2\u0f02\u0f11\5\u026a\u0136\2\u0f03\u0f04\7\u0105\2") + buf.write("\2\u0f04\u0f05\7\u0191\2\2\u0f05\u0f06\5\u026a\u0136\2") + buf.write("\u0f06\u0f07\7~\2\2\u0f07\u0f08\5\u0210\u0109\2\u0f08") + buf.write("\u0f11\3\2\2\2\u0f09\u0f0a\7\u0106\2\2\u0f0a\u0f0b\5\u0210") + buf.write("\u0109\2\u0f0b\u0f0c\7\u01a3\2\2\u0f0c\u0f0d\5\u026a\u0136") + buf.write("\2\u0f0d\u0f11\3\2\2\2\u0f0e\u0f0f\7\u0109\2\2\u0f0f\u0f11") + buf.write("\5\u026a\u0136\2\u0f10\u0e94\3\2\2\2\u0f10\u0e97\3\2\2") + buf.write("\2\u0f10\u0e9b\3\2\2\2\u0f10\u0ea2\3\2\2\2\u0f10\u0ea4") + buf.write("\3\2\2\2\u0f10\u0ea6\3\2\2\2\u0f10\u0eae\3\2\2\2\u0f10") + buf.write("\u0eb0\3\2\2\2\u0f10\u0eb2\3\2\2\2\u0f10\u0eb4\3\2\2\2") + buf.write("\u0f10\u0eb6\3\2\2\2\u0f10\u0eb9\3\2\2\2\u0f10\u0ebe\3") + buf.write("\2\2\2\u0f10\u0ec2\3\2\2\2\u0f10\u0ec4\3\2\2\2\u0f10\u0ec8") + buf.write("\3\2\2\2\u0f10\u0ecc\3\2\2\2\u0f10\u0ece\3\2\2\2\u0f10") + buf.write("\u0ed4\3\2\2\2\u0f10\u0eda\3\2\2\2\u0f10\u0ede\3\2\2\2") + buf.write("\u0f10\u0ee0\3\2\2\2\u0f10\u0ee2\3\2\2\2\u0f10\u0ee7\3") + buf.write("\2\2\2\u0f10\u0ee9\3\2\2\2\u0f10\u0eeb\3\2\2\2\u0f10\u0eed") + buf.write("\3\2\2\2\u0f10\u0eef\3\2\2\2\u0f10\u0ef1\3\2\2\2\u0f10") + buf.write("\u0ef3\3\2\2\2\u0f10\u0ef7\3\2\2\2\u0f10\u0efb\3\2\2\2") + buf.write("\u0f10\u0eff\3\2\2\2\u0f10\u0f03\3\2\2\2\u0f10\u0f09\3") + buf.write("\2\2\2\u0f10\u0f0e\3\2\2\2\u0f11\u0133\3\2\2\2\u0f12\u0f13") + buf.write("\t\62\2\2\u0f13\u0f14\5\u026a\u0136\2\u0f14\u0f15\5\u0142") + buf.write("\u00a2\2\u0f15\u0f40\3\2\2\2\u0f16\u0f17\7\u017e\2\2\u0f17") + buf.write("\u0f40\5\u026a\u0136\2\u0f18\u0f19\7\67\2\2\u0f19\u0f40") + buf.write("\5\u0210\u0109\2\u0f1a\u0f1b\7G\2\2\u0f1b\u0f40\5\u026a") + buf.write("\u0136\2\u0f1c\u0f1d\7P\2\2\u0f1d\u0f1e\7\u0106\2\2\u0f1e") + buf.write("\u0f40\5\u0210\u0109\2\u0f1f\u0f21\7\u0192\2\2\u0f20\u0f1f") + buf.write("\3\2\2\2\u0f20\u0f21\3\2\2\2\u0f21\u0f22\3\2\2\2\u0f22") + buf.write("\u0f23\7\u01af\2\2\u0f23\u0f40\5\u026a\u0136\2\u0f24\u0f25") + buf.write("\7\177\2\2\u0f25\u0f26\7\u009d\2\2\u0f26\u0f40\7\u0262") + buf.write("\2\2\u0f27\u0f29\7\u008c\2\2\u0f28\u0f27\3\2\2\2\u0f28") + buf.write("\u0f29\3\2\2\2\u0f29\u0f2a\3\2\2\2\u0f2a\u0f2b\7\u011a") + buf.write("\2\2\u0f2b\u0f40\5\u026a\u0136\2\u0f2c\u0f2e\7\u00b9\2") + buf.write("\2\u0f2d\u0f2c\3\2\2\2\u0f2d\u0f2e\3\2\2\2\u0f2e\u0f2f") + buf.write("\3\2\2\2\u0f2f\u0f30\7~\2\2\u0f30\u0f40\5\u026a\u0136") + buf.write("\2\u0f31\u0f32\7\u00bd\2\2\u0f32\u0f40\5\u0210\u0109\2") + buf.write("\u0f33\u0f34\7\u00d3\2\2\u0f34\u0f40\5\u0210\u0109\2\u0f35") + buf.write("\u0f36\7\u00db\2\2\u0f36\u0f40\5\u0210\u0109\2\u0f37\u0f38") + buf.write("\7\u00e1\2\2\u0f38\u0f40\5\u026a\u0136\2\u0f39\u0f3a\7") + buf.write("\u00f9\2\2\u0f3a\u0f40\5\u0210\u0109\2\u0f3b\u0f3c\7\u00fe") + buf.write("\2\2\u0f3c\u0f40\5\u0210\u0109\2\u0f3d\u0f3e\7\u0109\2") + buf.write("\2\u0f3e\u0f40\5\u026a\u0136\2\u0f3f\u0f12\3\2\2\2\u0f3f") + buf.write("\u0f16\3\2\2\2\u0f3f\u0f18\3\2\2\2\u0f3f\u0f1a\3\2\2\2") + buf.write("\u0f3f\u0f1c\3\2\2\2\u0f3f\u0f20\3\2\2\2\u0f3f\u0f24\3") + buf.write("\2\2\2\u0f3f\u0f28\3\2\2\2\u0f3f\u0f2d\3\2\2\2\u0f3f\u0f31") + buf.write("\3\2\2\2\u0f3f\u0f33\3\2\2\2\u0f3f\u0f35\3\2\2\2\u0f3f") + buf.write("\u0f37\3\2\2\2\u0f3f\u0f39\3\2\2\2\u0f3f\u0f3b\3\2\2\2") + buf.write("\u0f3f\u0f3d\3\2\2\2\u0f40\u0135\3\2\2\2\u0f41\u0f42\7") + buf.write("\u01a5\2\2\u0f42\u0f44\7\u00cc\2\2\u0f43\u0f41\3\2\2\2") + buf.write("\u0f43\u0f44\3\2\2\2\u0f44\u0f45\3\2\2\2\u0f45\u0f46\t") + buf.write("\22\2\2\u0f46\u0f4c\5\u0140\u00a1\2\u0f47\u0f4a\7\u00d1") + buf.write("\2\2\u0f48\u0f4b\5\u0224\u0113\2\u0f49\u0f4b\5\u013c\u009f") + buf.write("\2\u0f4a\u0f48\3\2\2\2\u0f4a\u0f49\3\2\2\2\u0f4b\u0f4d") + buf.write("\3\2\2\2\u0f4c\u0f47\3\2\2\2\u0f4c\u0f4d\3\2\2\2\u0f4d") + buf.write("\u0f4e\3\2\2\2\u0f4e\u0f4f\5\u0138\u009d\2\u0f4f\u0137") + buf.write("\3\2\2\2\u0f50\u0f52\5h\65\2\u0f51\u0f50\3\2\2\2\u0f52") + buf.write("\u0f53\3\2\2\2\u0f53\u0f51\3\2\2\2\u0f53\u0f54\3\2\2\2") + buf.write("\u0f54\u0f56\3\2\2\2\u0f55\u0f57\5\u01e2\u00f2\2\u0f56") + buf.write("\u0f55\3\2\2\2\u0f56\u0f57\3\2\2\2\u0f57\u0139\3\2\2\2") + buf.write("\u0f58\u0f59\7\u0191\2\2\u0f59\u0f5a\7\u0109\2\2\u0f5a") + buf.write("\u0f5b\5\u0224\u0113\2\u0f5b\u013b\3\2\2\2\u0f5c\u0f5d") + buf.write("\7\u01af\2\2\u0f5d\u0f5e\7\u024b\2\2\u0f5e\u0f63\5\u013e") + buf.write("\u00a0\2\u0f5f\u0f60\7\u0245\2\2\u0f60\u0f62\5\u013e\u00a0") + buf.write("\2\u0f61\u0f5f\3\2\2\2\u0f62\u0f65\3\2\2\2\u0f63\u0f61") + buf.write("\3\2\2\2\u0f63\u0f64\3\2\2\2\u0f64\u0f66\3\2\2\2\u0f65") + buf.write("\u0f63\3\2\2\2\u0f66\u0f67\7\u024c\2\2\u0f67\u013d\3\2") + buf.write("\2\2\u0f68\u0f69\5\u0210\u0109\2\u0f69\u0f6a\5\u0224\u0113") + buf.write("\2\u0f6a\u013f\3\2\2\2\u0f6b\u0f6c\5\u026a\u0136\2\u0f6c") + buf.write("\u0f6d\5\u0142\u00a2\2\u0f6d\u0141\3\2\2\2\u0f6e\u0f7d") + buf.write("\7\u024b\2\2\u0f6f\u0f74\5\u0148\u00a5\2\u0f70\u0f71\7") + buf.write("\u0245\2\2\u0f71\u0f73\5\u0148\u00a5\2\u0f72\u0f70\3\2") + buf.write("\2\2\u0f73\u0f76\3\2\2\2\u0f74\u0f72\3\2\2\2\u0f74\u0f75") + buf.write("\3\2\2\2\u0f75\u0f78\3\2\2\2\u0f76\u0f74\3\2\2\2\u0f77") + buf.write("\u0f6f\3\2\2\2\u0f77\u0f78\3\2\2\2\u0f78\u0f7a\3\2\2\2") + buf.write("\u0f79\u0f7b\5\u0144\u00a3\2\u0f7a\u0f79\3\2\2\2\u0f7a") + buf.write("\u0f7b\3\2\2\2\u0f7b\u0f7e\3\2\2\2\u0f7c\u0f7e\7\u024f") + buf.write("\2\2\u0f7d\u0f77\3\2\2\2\u0f7d\u0f7c\3\2\2\2\u0f7e\u0f7f") + buf.write("\3\2\2\2\u0f7f\u0f80\7\u024c\2\2\u0f80\u0143\3\2\2\2\u0f81") + buf.write("\u0f82\7\u01a6\2\2\u0f82\u0f83\7\26\2\2\u0f83\u0f88\5") + buf.write("\u0148\u00a5\2\u0f84\u0f85\7\u0245\2\2\u0f85\u0f87\5\u0148") + buf.write("\u00a5\2\u0f86\u0f84\3\2\2\2\u0f87\u0f8a\3\2\2\2\u0f88") + buf.write("\u0f86\3\2\2\2\u0f88\u0f89\3\2\2\2\u0f89\u0145\3\2\2\2") + buf.write("\u0f8a\u0f88\3\2\2\2\u0f8b\u0f8f\7\u0268\2\2\u0f8c\u0f8e") + buf.write("\7\u026f\2\2\u0f8d\u0f8c\3\2\2\2\u0f8e\u0f91\3\2\2\2\u0f8f") + buf.write("\u0f8d\3\2\2\2\u0f8f\u0f90\3\2\2\2\u0f90\u0f92\3\2\2\2") + buf.write("\u0f91\u0f8f\3\2\2\2\u0f92\u0f95\7\u0270\2\2\u0f93\u0f95") + buf.write("\7\u0267\2\2\u0f94\u0f8b\3\2\2\2\u0f94\u0f93\3\2\2\2\u0f95") + buf.write("\u0147\3\2\2\2\u0f96\u0f98\5\u014a\u00a6\2\u0f97\u0f96") + buf.write("\3\2\2\2\u0f97\u0f98\3\2\2\2\u0f98\u0f9a\3\2\2\2\u0f99") + buf.write("\u0f9b\5\u0212\u010a\2\u0f9a\u0f99\3\2\2\2\u0f9a\u0f9b") + buf.write("\3\2\2\2\u0f9b\u0f9c\3\2\2\2\u0f9c\u0f9f\5\u0224\u0113") + buf.write("\2\u0f9d\u0f9e\t\64\2\2\u0f9e\u0fa0\5\u0230\u0119\2\u0f9f") + buf.write("\u0f9d\3\2\2\2\u0f9f\u0fa0\3\2\2\2\u0fa0\u0149\3\2\2\2") + buf.write("\u0fa1\u0fa2\t\65\2\2\u0fa2\u014b\3\2\2\2\u0fa3\u0fa5") + buf.write("\t\66\2\2\u0fa4\u0fa3\3\2\2\2\u0fa4\u0fa5\3\2\2\2\u0fa5") + buf.write("\u0fa6\3\2\2\2\u0fa6\u0fa8\7\u00e1\2\2\u0fa7\u0fa9\5\u019a") + buf.write("\u00ce\2\u0fa8\u0fa7\3\2\2\2\u0fa8\u0fa9\3\2\2\2\u0fa9") + buf.write("\u0faa\3\2\2\2\u0faa\u0fae\5\u026a\u0136\2\u0fab\u0fad") + buf.write("\5\u014e\u00a8\2\u0fac\u0fab\3\2\2\2\u0fad\u0fb0\3\2\2") + buf.write("\2\u0fae\u0fac\3\2\2\2\u0fae\u0faf\3\2\2\2\u0faf\u014d") + buf.write("\3\2\2\2\u0fb0\u0fae\3\2\2\2\u0fb1\u0fb2\7\u0176\2\2\u0fb2") + buf.write("\u0fd6\t\67\2\2\u0fb3\u0fb4\7\u00e1\2\2\u0fb4\u0fb5\7") + buf.write("\u0094\2\2\u0fb5\u0fd6\5\u026a\u0136\2\u0fb6\u0fb8\7p") + buf.write("\2\2\u0fb7\u0fb9\7\26\2\2\u0fb8\u0fb7\3\2\2\2\u0fb8\u0fb9") + buf.write("\3\2\2\2\u0fb9\u0fba\3\2\2\2\u0fba\u0fd6\5\u0152\u00aa") + buf.write("\2\u0fbb\u0fbc\7\u0090\2\2\u0fbc\u0fc0\5\u0152\u00aa\2") + buf.write("\u0fbd\u0fbe\7\u0098\2\2\u0fbe\u0fc0\7\u0090\2\2\u0fbf") + buf.write("\u0fbb\3\2\2\2\u0fbf\u0fbd\3\2\2\2\u0fc0\u0fd6\3\2\2\2") + buf.write("\u0fc1\u0fc2\7\u008d\2\2\u0fc2\u0fc6\5\u0152\u00aa\2\u0fc3") + buf.write("\u0fc4\7\u0098\2\2\u0fc4\u0fc6\7\u008d\2\2\u0fc5\u0fc1") + buf.write("\3\2\2\2\u0fc5\u0fc3\3\2\2\2\u0fc6\u0fd6\3\2\2\2\u0fc7") + buf.write("\u0fc9\7\u00f0\2\2\u0fc8\u0fca\7\u01bc\2\2\u0fc9\u0fc8") + buf.write("\3\2\2\2\u0fc9\u0fca\3\2\2\2\u0fca\u0fcb\3\2\2\2\u0fcb") + buf.write("\u0fd6\5\u0152\u00aa\2\u0fcc\u0fcd\7\27\2\2\u0fcd\u0fd6") + buf.write("\5\u0152\u00aa\2\u0fce\u0fd0\7\u0098\2\2\u0fcf\u0fce\3") + buf.write("\2\2\2\u0fcf\u0fd0\3\2\2\2\u0fd0\u0fd1\3\2\2\2\u0fd1\u0fd6") + buf.write("\7\65\2\2\u0fd2\u0fd3\7\u00a9\2\2\u0fd3\u0fd4\7\26\2\2") + buf.write("\u0fd4\u0fd6\5\u026a\u0136\2\u0fd5\u0fb1\3\2\2\2\u0fd5") + buf.write("\u0fb3\3\2\2\2\u0fd5\u0fb6\3\2\2\2\u0fd5\u0fbf\3\2\2\2") + buf.write("\u0fd5\u0fc5\3\2\2\2\u0fd5\u0fc7\3\2\2\2\u0fd5\u0fcc\3") + buf.write("\2\2\2\u0fd5\u0fcf\3\2\2\2\u0fd5\u0fd2\3\2\2\2\u0fd6\u014f") + buf.write("\3\2\2\2\u0fd7\u0fd9\5\u0154\u00ab\2\u0fd8\u0fd7\3\2\2") + buf.write("\2\u0fd8\u0fd9\3\2\2\2\u0fd9\u0fda\3\2\2\2\u0fda\u0fdb") + buf.write("\7\u0262\2\2\u0fdb\u0151\3\2\2\2\u0fdc\u0fde\5\u0154\u00ab") + buf.write("\2\u0fdd\u0fdc\3\2\2\2\u0fdd\u0fde\3\2\2\2\u0fde\u0fdf") + buf.write("\3\2\2\2\u0fdf\u0fe0\5\u023e\u0120\2\u0fe0\u0153\3\2\2") + buf.write("\2\u0fe1\u0fe2\t8\2\2\u0fe2\u0155\3\2\2\2\u0fe3\u0fe5") + buf.write("\7\u00db\2\2\u0fe4\u0fe6\5\u019a\u00ce\2\u0fe5\u0fe4\3") + buf.write("\2\2\2\u0fe5\u0fe6\3\2\2\2\u0fe6\u0fe8\3\2\2\2\u0fe7\u0fe9") + buf.write("\5\u0210\u0109\2\u0fe8\u0fe7\3\2\2\2\u0fe8\u0fe9\3\2\2") + buf.write("\2\u0fe9\u0fec\3\2\2\2\u0fea\u0feb\7\u0159\2\2\u0feb\u0fed") + buf.write("\5,\27\2\u0fec\u0fea\3\2\2\2\u0fec\u0fed\3\2\2\2\u0fed") + buf.write("\u0157\3\2\2\2\u0fee\u0fef\7\u00b2\2\2\u0fef\u0ff0\5\u0210") + buf.write("\u0109\2\u0ff0\u0ff1\7\u01a3\2\2\u0ff1\u0ff4\5\u026a\u0136") + buf.write("\2\u0ff2\u0ff3\7\u0176\2\2\u0ff3\u0ff5\t9\2\2\u0ff4\u0ff2") + buf.write("\3\2\2\2\u0ff4\u0ff5\3\2\2\2\u0ff5\u0ff8\3\2\2\2\u0ff6") + buf.write("\u0ff7\7\u0191\2\2\u0ff7\u0ff9\t:\2\2\u0ff8\u0ff6\3\2") + buf.write("\2\2\u0ff8\u0ff9\3\2\2\2\u0ff9\u1003\3\2\2\2\u0ffa\u0ffb") + buf.write("\7\u01b1\2\2\u0ffb\u1000\5,\27\2\u0ffc\u0ffd\7\u0245\2") + buf.write("\2\u0ffd\u0fff\5,\27\2\u0ffe\u0ffc\3\2\2\2\u0fff\u1002") + buf.write("\3\2\2\2\u1000\u0ffe\3\2\2\2\u1000\u1001\3\2\2\2\u1001") + buf.write("\u1004\3\2\2\2\u1002\u1000\3\2\2\2\u1003\u0ffa\3\2\2\2") + buf.write("\u1003\u1004\3\2\2\2\u1004\u1007\3\2\2\2\u1005\u1006\7") + buf.write("\u01b7\2\2\u1006\u1008\5\u0230\u0119\2\u1007\u1005\3\2") + buf.write("\2\2\u1007\u1008\3\2\2\2\u1008\u100c\3\2\2\2\u1009\u100a") + buf.write("\7\u01bc\2\2\u100a\u100b\7\u017c\2\2\u100b\u100d\5\u0230") + buf.write("\u0119\2\u100c\u1009\3\2\2\2\u100c\u100d\3\2\2\2\u100d") + buf.write("\u0159\3\2\2\2\u100e\u100f\7\u00b2\2\2\u100f\u1010\5\u0210") + buf.write("\u0109\2\u1010\u1011\7\u01a3\2\2\u1011\u1012\5\u026a\u0136") + buf.write("\2\u1012\u1013\5\u01ee\u00f8\2\u1013\u102d\3\2\2\2\u1014") + buf.write("\u1015\7\u00b2\2\2\u1015\u1016\5\u0210\u0109\2\u1016\u1017") + buf.write("\7\u01a3\2\2\u1017\u1021\5\u026a\u0136\2\u1018\u1019\7") + buf.write("\u01b1\2\2\u1019\u101e\5,\27\2\u101a\u101b\7\u0245\2\2") + buf.write("\u101b\u101d\5,\27\2\u101c\u101a\3\2\2\2\u101d\u1020\3") + buf.write("\2\2\2\u101e\u101c\3\2\2\2\u101e\u101f\3\2\2\2\u101f\u1022") + buf.write("\3\2\2\2\u1020\u101e\3\2\2\2\u1021\u1018\3\2\2\2\u1021") + buf.write("\u1022\3\2\2\2\u1022\u1025\3\2\2\2\u1023\u1024\7\u01b7") + buf.write("\2\2\u1024\u1026\5\u0230\u0119\2\u1025\u1023\3\2\2\2\u1025") + buf.write("\u1026\3\2\2\2\u1026\u102a\3\2\2\2\u1027\u1028\7\u01bc") + buf.write("\2\2\u1028\u1029\7\u017c\2\2\u1029\u102b\5\u0230\u0119") + buf.write("\2\u102a\u1027\3\2\2\2\u102a\u102b\3\2\2\2\u102b\u102d") + buf.write("\3\2\2\2\u102c\u100e\3\2\2\2\u102c\u1014\3\2\2\2\u102d") + buf.write("\u015b\3\2\2\2\u102e\u1030\7\u00b2\2\2\u102f\u1031\5\u0198") + buf.write("\u00cd\2\u1030\u102f\3\2\2\2\u1030\u1031\3\2\2\2\u1031") + buf.write("\u1032\3\2\2\2\u1032\u1033\5\u0210\u0109\2\u1033\u1034") + buf.write("\7\u01a3\2\2\u1034\u1036\5\u026a\u0136\2\u1035\u1037\5") + buf.write("\u01f8\u00fd\2\u1036\u1035\3\2\2\2\u1036\u1037\3\2\2\2") + buf.write("\u1037\u015d\3\2\2\2\u1038\u1039\7\u00f9\2\2\u1039\u103a") + buf.write("\5\u0210\u0109\2\u103a\u103b\7*\2\2\u103b\u103c\7\u0267") + buf.write("\2\2\u103c\u103d\7\u00bd\2\2\u103d\u103f\5\u02b6\u015c") + buf.write("\2\u103e\u1040\5\u01e2\u00f2\2\u103f\u103e\3\2\2\2\u103f") + buf.write("\u1040\3\2\2\2\u1040\u015f\3\2\2\2\u1041\u1042\7\u00f9") + buf.write("\2\2\u1042\u1043\5\u0210\u0109\2\u1043\u1044\5\u0162\u00b2") + buf.write("\2\u1044\u0161\3\2\2\2\u1045\u1046\7*\2\2\u1046\u1059") + buf.write("\5\u0146\u00a4\2\u1047\u1048\7\u00e6\2\2\u1048\u1049\7") + buf.write("\u00bd\2\2\u1049\u104b\5\u02b6\u015c\2\u104a\u104c\5\u01e2") + buf.write("\u00f2\2\u104b\u104a\3\2\2\2\u104b\u104c\3\2\2\2\u104c") + buf.write("\u1059\3\2\2\2\u104d\u104e\7\u00c6\2\2\u104e\u1050\7\u00bd") + buf.write("\2\2\u104f\u1051\5\u01e2\u00f2\2\u1050\u104f\3\2\2\2\u1050") + buf.write("\u1051\3\2\2\2\u1051\u1059\3\2\2\2\u1052\u1059\7K\2\2") + buf.write("\u1053\u1059\7D\2\2\u1054\u1055\7\u00e6\2\2\u1055\u1059") + buf.write("\5\u01dc\u00ef\2\u1056\u1059\5\u01ec\u00f7\2\u1057\u1059") + buf.write("\5\u01ee\u00f8\2\u1058\u1045\3\2\2\2\u1058\u1047\3\2\2") + buf.write("\2\u1058\u104d\3\2\2\2\u1058\u1052\3\2\2\2\u1058\u1053") + buf.write("\3\2\2\2\u1058\u1054\3\2\2\2\u1058\u1056\3\2\2\2\u1058") + buf.write("\u1057\3\2\2\2\u1059\u0163\3\2\2\2\u105a\u105b\7\u017b") + buf.write("\2\2\u105b\u105c\7\u024b\2\2\u105c\u105d\5\u0224\u0113") + buf.write("\2\u105d\u105e\7\u0176\2\2\u105e\u105f\5\u0224\u0113\2") + buf.write("\u105f\u1069\7\u024c\2\2\u1060\u1061\7\u01bc\2\2\u1061") + buf.write("\u1062\7^\2\2\u1062\u1063\5\u026a\u0136\2\u1063\u1064") + buf.write("\5\u0142\u00a2\2\u1064\u106a\3\2\2\2\u1065\u1066\7\u011f") + buf.write("\2\2\u1066\u106a\7^\2\2\u1067\u1068\7\u01bc\2\2\u1068") + buf.write("\u106a\7\u0135\2\2\u1069\u1060\3\2\2\2\u1069\u1065\3\2") + buf.write("\2\2\u1069\u1067\3\2\2\2\u106a\u106f\3\2\2\2\u106b\u106c") + buf.write("\7\u0176\2\2\u106c\u1070\7\17\2\2\u106d\u106e\7\u0176") + buf.write("\2\2\u106e\u1070\7l\2\2\u106f\u106b\3\2\2\2\u106f\u106d") + buf.write("\3\2\2\2\u106f\u1070\3\2\2\2\u1070\u0165\3\2\2\2\u1071") + buf.write("\u1073\7\u017b\2\2\u1072\u1074\5\u0198\u00cd\2\u1073\u1072") + buf.write("\3\2\2\2\u1073\u1074\3\2\2\2\u1074\u1075\3\2\2\2\u1075") + buf.write("\u1076\7\u024b\2\2\u1076\u1077\5\u0224\u0113\2\u1077\u1078") + buf.write("\7\u0176\2\2\u1078\u1079\5\u0224\u0113\2\u1079\u107b\7") + buf.write("\u024c\2\2\u107a\u107c\5\u01f8\u00fd\2\u107b\u107a\3\2") + buf.write("\2\2\u107b\u107c\3\2\2\2\u107c\u0167\3\2\2\2\u107d\u107e") + buf.write("\7\u00a2\2\2\u107e\u107f\7X\2\2\u107f\u1080\5\u026a\u0136") + buf.write("\2\u1080\u1081\7\u01b7\2\2\u1081\u1082\5\u0210\u0109\2") + buf.write("\u1082\u0169\3\2\2\2\u1083\u1084\7\u00a2\2\2\u1084\u1085") + buf.write("\7X\2\2\u1085\u1086\5\u026a\u0136\2\u1086\u1087\7\u01b7") + buf.write("\2\2\u1087\u1088\5\u0210\u0109\2\u1088\u1089\5\u016c\u00b7") + buf.write("\2\u1089\u016b\3\2\2\2\u108a\u10a0\5\u01ee\u00f8\2\u108b") + buf.write("\u10a0\5\u01ec\u00f7\2\u108c\u10a0\5\u01f0\u00f9\2\u108d") + buf.write("\u108e\7\7\2\2\u108e\u1093\5\u016e\u00b8\2\u108f\u1090") + buf.write("\7\u0245\2\2\u1090\u1092\5\u016e\u00b8\2\u1091\u108f\3") + buf.write("\2\2\2\u1092\u1095\3\2\2\2\u1093\u1091\3\2\2\2\u1093\u1094") + buf.write("\3\2\2\2\u1094\u10a0\3\2\2\2\u1095\u1093\3\2\2\2\u1096") + buf.write("\u1097\7I\2\2\u1097\u109c\5\u0170\u00b9\2\u1098\u1099") + buf.write("\7\u0245\2\2\u1099\u109b\5\u0170\u00b9\2\u109a\u1098\3") + buf.write("\2\2\2\u109b\u109e\3\2\2\2\u109c\u109a\3\2\2\2\u109c\u109d") + buf.write("\3\2\2\2\u109d\u10a0\3\2\2\2\u109e\u109c\3\2\2\2\u109f") + buf.write("\u108a\3\2\2\2\u109f\u108b\3\2\2\2\u109f\u108c\3\2\2\2") + buf.write("\u109f\u108d\3\2\2\2\u109f\u1096\3\2\2\2\u10a0\u016d\3") + buf.write("\2\2\2\u10a1\u10a2\7\u00a2\2\2\u10a2\u10a3\5\u023e\u0120") + buf.write("\2\u10a3\u10aa\5\u00dco\2\u10a4\u10a5\7\u0191\2\2\u10a5") + buf.write("\u10ab\7\u00de\2\2\u10a6\u10a7\7\u0191\2\2\u10a7\u10a8") + buf.write("\7\u01a6\2\2\u10a8\u10a9\7\26\2\2\u10a9\u10ab\5\u026a") + buf.write("\u0136\2\u10aa\u10a4\3\2\2\2\u10aa\u10a6\3\2\2\2\u10aa") + buf.write("\u10ab\3\2\2\2\u10ab\u10c0\3\2\2\2\u10ac\u10ad\7^\2\2") + buf.write("\u10ad\u10bb\5\u023e\u0120\2\u10ae\u10b1\7\u024b\2\2\u10af") + buf.write("\u10b2\5\u0224\u0113\2\u10b0\u10b2\7\u013c\2\2\u10b1\u10af") + buf.write("\3\2\2\2\u10b1\u10b0\3\2\2\2\u10b2\u10b8\3\2\2\2\u10b3") + buf.write("\u10b6\7\u0245\2\2\u10b4\u10b7\5\u0224\u0113\2\u10b5\u10b7") + buf.write("\7\u013c\2\2\u10b6\u10b4\3\2\2\2\u10b6\u10b5\3\2\2\2\u10b7") + buf.write("\u10b9\3\2\2\2\u10b8\u10b3\3\2\2\2\u10b8\u10b9\3\2\2\2") + buf.write("\u10b9\u10ba\3\2\2\2\u10ba\u10bc\7\u024c\2\2\u10bb\u10ae") + buf.write("\3\2\2\2\u10bb\u10bc\3\2\2\2\u10bc\u10bd\3\2\2\2\u10bd") + buf.write("\u10be\5\u0246\u0124\2\u10be\u10c0\3\2\2\2\u10bf\u10a1") + buf.write("\3\2\2\2\u10bf\u10ac\3\2\2\2\u10c0\u016f\3\2\2\2\u10c1") + buf.write("\u10c2\t;\2\2\u10c2\u10c3\5\u023e\u0120\2\u10c3\u10c6") + buf.write("\7\u024b\2\2\u10c4\u10c7\5\u0224\u0113\2\u10c5\u10c7\7") + buf.write("\u013c\2\2\u10c6\u10c4\3\2\2\2\u10c6\u10c5\3\2\2\2\u10c7") + buf.write("\u10cd\3\2\2\2\u10c8\u10cb\7\u0245\2\2\u10c9\u10cc\5\u0224") + buf.write("\u0113\2\u10ca\u10cc\7\u013c\2\2\u10cb\u10c9\3\2\2\2\u10cb") + buf.write("\u10ca\3\2\2\2\u10cc\u10ce\3\2\2\2\u10cd\u10c8\3\2\2\2") + buf.write("\u10cd\u10ce\3\2\2\2\u10ce\u10cf\3\2\2\2\u10cf\u10d0\7") + buf.write("\u024c\2\2\u10d0\u0171\3\2\2\2\u10d1\u10d2\7\u00a2\2\2") + buf.write("\u10d2\u10d4\7X\2\2\u10d3\u10d5\5\u0198\u00cd\2\u10d4") + buf.write("\u10d3\3\2\2\2\u10d4\u10d5\3\2\2\2\u10d5\u10d6\3\2\2\2") + buf.write("\u10d6\u10d7\5\u026a\u0136\2\u10d7\u10d8\7\u01b7\2\2\u10d8") + buf.write("\u10da\5\u0210\u0109\2\u10d9\u10db\5\u01f8\u00fd\2\u10da") + buf.write("\u10d9\3\2\2\2\u10da\u10db\3\2\2\2\u10db\u0173\3\2\2\2") + buf.write("\u10dc\u10dd\7\u00a2\2\2\u10dd\u10de\7 \2\2\u10de\u10e0") + buf.write("\5\u026a\u0136\2\u10df\u10e1\7\u0187\2\2\u10e0\u10df\3") + buf.write("\2\2\2\u10e0\u10e1\3\2\2\2\u10e1\u10e2\3\2\2\2\u10e2\u10e3") + buf.write("\7\u0191\2\2\u10e3\u10e4\7\u0109\2\2\u10e4\u10e5\5\u0224") + buf.write("\u0113\2\u10e5\u10e6\7\u01b7\2\2\u10e6\u10e9\5\u0210\u0109") + buf.write("\2\u10e7\u10e8\7X\2\2\u10e8\u10ea\5\u026a\u0136\2\u10e9") + buf.write("\u10e7\3\2\2\2\u10e9\u10ea\3\2\2\2\u10ea\u10eb\3\2\2\2") + buf.write("\u10eb\u10ec\7\u0176\2\2\u10ec\u10f1\5\u0176\u00bc\2\u10ed") + buf.write("\u10ee\7\u0245\2\2\u10ee\u10f0\5\u0176\u00bc\2\u10ef\u10ed") + buf.write("\3\2\2\2\u10f0\u10f3\3\2\2\2\u10f1\u10ef\3\2\2\2\u10f1") + buf.write("\u10f2\3\2\2\2\u10f2\u0175\3\2\2\2\u10f3\u10f1\3\2\2\2") + buf.write("\u10f4\u10f5\7\u00a2\2\2\u10f5\u10f6\5\u023e\u0120\2\u10f6") + buf.write("\u1102\5\u00fe\u0080\2\u10f7\u10fa\7\u024b\2\2\u10f8\u10fb") + buf.write("\5\u0224\u0113\2\u10f9\u10fb\7\u013c\2\2\u10fa\u10f8\3") + buf.write("\2\2\2\u10fa\u10f9\3\2\2\2\u10fb\u10fc\3\2\2\2\u10fc\u10ff") + buf.write("\7\u0245\2\2\u10fd\u1100\5\u0224\u0113\2\u10fe\u1100\7") + buf.write("\u013c\2\2\u10ff\u10fd\3\2\2\2\u10ff\u10fe\3\2\2\2\u1100") + buf.write("\u1101\3\2\2\2\u1101\u1103\7\u024c\2\2\u1102\u10f7\3\2") + buf.write("\2\2\u1102\u1103\3\2\2\2\u1103\u110a\3\2\2\2\u1104\u1105") + buf.write("\7\u0191\2\2\u1105\u110b\7\u00de\2\2\u1106\u1107\7\u0191") + buf.write("\2\2\u1107\u1108\7\u01a6\2\2\u1108\u1109\7\26\2\2\u1109") + buf.write("\u110b\5\u026a\u0136\2\u110a\u1104\3\2\2\2\u110a\u1106") + buf.write("\3\2\2\2\u110a\u110b\3\2\2\2\u110b\u1122\3\2\2\2\u110c") + buf.write("\u110d\7^\2\2\u110d\u111b\5\u023e\u0120\2\u110e\u1111") + buf.write("\7\u024b\2\2\u110f\u1112\5\u0224\u0113\2\u1110\u1112\7") + buf.write("\u013c\2\2\u1111\u110f\3\2\2\2\u1111\u1110\3\2\2\2\u1112") + buf.write("\u1118\3\2\2\2\u1113\u1116\7\u0245\2\2\u1114\u1117\5\u0224") + buf.write("\u0113\2\u1115\u1117\7\u013c\2\2\u1116\u1114\3\2\2\2\u1116") + buf.write("\u1115\3\2\2\2\u1117\u1119\3\2\2\2\u1118\u1113\3\2\2\2") + buf.write("\u1118\u1119\3\2\2\2\u1119\u111a\3\2\2\2\u111a\u111c\7") + buf.write("\u024c\2\2\u111b\u110e\3\2\2\2\u111b\u111c\3\2\2\2\u111c") + buf.write("\u111d\3\2\2\2\u111d\u111e\5\u0246\u0124\2\u111e\u1122") + buf.write("\3\2\2\2\u111f\u1120\7\u00f5\2\2\u1120\u1122\5\u0224\u0113") + buf.write("\2\u1121\u10f4\3\2\2\2\u1121\u110c\3\2\2\2\u1121\u111f") + buf.write("\3\2\2\2\u1122\u0177\3\2\2\2\u1123\u1124\7\u00a2\2\2\u1124") + buf.write("\u1125\7 \2\2\u1125\u1126\5\u026a\u0136\2\u1126\u1127") + buf.write("\7\u01b7\2\2\u1127\u112b\5\u0210\u0109\2\u1128\u112c\5") + buf.write("\u01ee\u00f8\2\u1129\u112c\5\u01ec\u00f7\2\u112a\u112c") + buf.write("\5\u01f0\u00f9\2\u112b\u1128\3\2\2\2\u112b\u1129\3\2\2") + buf.write("\2\u112b\u112a\3\2\2\2\u112c\u0179\3\2\2\2\u112d\u112e") + buf.write("\7\u00a2\2\2\u112e\u1130\7 \2\2\u112f\u1131\5\u0198\u00cd") + buf.write("\2\u1130\u112f\3\2\2\2\u1130\u1131\3\2\2\2\u1131\u1132") + buf.write("\3\2\2\2\u1132\u1133\5\u026a\u0136\2\u1133\u1134\7\u01b7") + buf.write("\2\2\u1134\u1136\5\u0210\u0109\2\u1135\u1137\5\u01f8\u00fd") + buf.write("\2\u1136\u1135\3\2\2\2\u1136\u1137\3\2\2\2\u1137\u017b") + buf.write("\3\2\2\2\u1138\u113a\7\u0187\2\2\u1139\u1138\3\2\2\2\u1139") + buf.write("\u113a\3\2\2\2\u113a\u113b\3\2\2\2\u113b\u113c\7.\2\2") + buf.write("\u113c\u113d\5\u026a\u0136\2\u113d\u113e\7\u0191\2\2\u113e") + buf.write("\u113f\7\u0267\2\2\u113f\u1140\7\u01b1\2\2\u1140\u1141") + buf.write("\7\u0267\2\2\u1141\u1142\7\u0193\2\2\u1142\u1143\5\u026a") + buf.write("\u0136\2\u1143\u017d\3\2\2\2\u1144\u1145\7.\2\2\u1145") + buf.write("\u1149\5\u026a\u0136\2\u1146\u114a\5\u01ee\u00f8\2\u1147") + buf.write("\u114a\5\u01ec\u00f7\2\u1148\u114a\5\u01f0\u00f9\2\u1149") + buf.write("\u1146\3\2\2\2\u1149\u1147\3\2\2\2\u1149\u1148\3\2\2\2") + buf.write("\u114a\u017f\3\2\2\2\u114b\u114c\7\u00bd\2\2\u114c\u115a") + buf.write("\5\u0210\u0109\2\u114d\u114e\7\u0191\2\2\u114e\u114f\7") + buf.write("\u01af\2\2\u114f\u1154\5\u0186\u00c4\2\u1150\u1151\7\u0245") + buf.write("\2\2\u1151\u1153\5\u0186\u00c4\2\u1152\u1150\3\2\2\2\u1153") + buf.write("\u1156\3\2\2\2\u1154\u1152\3\2\2\2\u1154\u1155\3\2\2\2") + buf.write("\u1155\u115b\3\2\2\2\u1156\u1154\3\2\2\2\u1157\u1158\7") + buf.write("\u0191\2\2\u1158\u1159\7\u0170\2\2\u1159\u115b\7\u00fd") + buf.write("\2\2\u115a\u114d\3\2\2\2\u115a\u1157\3\2\2\2\u115a\u115b") + buf.write("\3\2\2\2\u115b\u115d\3\2\2\2\u115c\u115e\5\u01e2\u00f2") + buf.write("\2\u115d\u115c\3\2\2\2\u115d\u115e\3\2\2\2\u115e\u0181") + buf.write("\3\2\2\2\u115f\u1160\7\u00bd\2\2\u1160\u1161\5\u0210\u0109") + buf.write("\2\u1161\u1162\5\u0184\u00c3\2\u1162\u0183\3\2\2\2\u1163") + buf.write("\u1172\5\u01ee\u00f8\2\u1164\u1172\5\u01ec\u00f7\2\u1165") + buf.write("\u1166\7\u00e6\2\2\u1166\u1172\5\u01dc\u00ef\2\u1167\u1168") + buf.write("\t<\2\2\u1168\u1169\7\u01af\2\2\u1169\u116e\5\u0186\u00c4") + buf.write("\2\u116a\u116b\7\u0245\2\2\u116b\u116d\5\u0186\u00c4\2") + buf.write("\u116c\u116a\3\2\2\2\u116d\u1170\3\2\2\2\u116e\u116c\3") + buf.write("\2\2\2\u116e\u116f\3\2\2\2\u116f\u1172\3\2\2\2\u1170\u116e") + buf.write("\3\2\2\2\u1171\u1163\3\2\2\2\u1171\u1164\3\2\2\2\u1171") + buf.write("\u1165\3\2\2\2\u1171\u1167\3\2\2\2\u1172\u0185\3\2\2\2") + buf.write("\u1173\u1175\7\u01a4\2\2\u1174\u1173\3\2\2\2\u1174\u1175") + buf.write("\3\2\2\2\u1175\u1176\3\2\2\2\u1176\u1178\5\u026a\u0136") + buf.write("\2\u1177\u1179\7\u024f\2\2\u1178\u1177\3\2\2\2\u1178\u1179") + buf.write("\3\2\2\2\u1179\u0187\3\2\2\2\u117a\u117b\7\u0106\2\2\u117b") + buf.write("\u117c\5\u0210\u0109\2\u117c\u117d\7\u01a3\2\2\u117d\u1183") + buf.write("\5\u026a\u0136\2\u117e\u1184\5\u01ee\u00f8\2\u117f\u1180") + buf.write("\7A\2\2\u1180\u1181\7\u01a3\2\2\u1181\u1182\7V\2\2\u1182") + buf.write("\u1184\5\u0210\u0109\2\u1183\u117e\3\2\2\2\u1183\u117f") + buf.write("\3\2\2\2\u1184\u0189\3\2\2\2\u1185\u1186\7\u00d9\2\2\u1186") + buf.write("\u1187\5\u0210\u0109\2\u1187\u1188\7\u01a3\2\2\u1188\u1189") + buf.write("\5\u026a\u0136\2\u1189\u118a\5\u01ee\u00f8\2\u118a\u018b") + buf.write("\3\2\2\2\u118b\u118e\5\u0190\u00c9\2\u118c\u118e\5\u018e") + buf.write("\u00c8\2\u118d\u118b\3\2\2\2\u118d\u118c\3\2\2\2\u118e") + buf.write("\u018d\3\2\2\2\u118f\u1190\7/\2\2\u1190\u1191\5\60\31") + buf.write("\2\u1191\u1197\7\u0193\2\2\u1192\u1194\7\u00bc\2\2\u1193") + buf.write("\u1192\3\2\2\2\u1193\u1194\3\2\2\2\u1194\u1195\3\2\2\2") + buf.write("\u1195\u1198\7\u0267\2\2\u1196\u1198\7\u00f3\2\2\u1197") + buf.write("\u1193\3\2\2\2\u1197\u1196\3\2\2\2\u1198\u11a3\3\2\2\2") + buf.write("\u1199\u119b\7\u01bc\2\2\u119a\u1199\3\2\2\2\u119a\u119b") + buf.write("\3\2\2\2\u119b\u11a1\3\2\2\2\u119c\u119d\7\u024b\2\2\u119d") + buf.write("\u119e\5\u0192\u00ca\2\u119e\u119f\7\u024c\2\2\u119f\u11a2") + buf.write("\3\2\2\2\u11a0\u11a2\5\u0192\u00ca\2\u11a1\u119c\3\2\2") + buf.write("\2\u11a1\u11a0\3\2\2\2\u11a2\u11a4\3\2\2\2\u11a3\u119a") + buf.write("\3\2\2\2\u11a3\u11a4\3\2\2\2\u11a4\u11a7\3\2\2\2\u11a5") + buf.write("\u11a6\7\u01ba\2\2\u11a6\u11a8\5\u0230\u0119\2\u11a7\u11a5") + buf.write("\3\2\2\2\u11a7\u11a8\3\2\2\2\u11a8\u018f\3\2\2\2\u11a9") + buf.write("\u11af\7/\2\2\u11aa\u11b0\5\60\31\2\u11ab\u11ac\7\u024b") + buf.write("\2\2\u11ac\u11ad\5\20\t\2\u11ad\u11ae\7\u024c\2\2\u11ae") + buf.write("\u11b0\3\2\2\2\u11af\u11aa\3\2\2\2\u11af\u11ab\3\2\2\2") + buf.write("\u11b0\u11b1\3\2\2\2\u11b1\u11b7\7\u01b1\2\2\u11b2\u11b4") + buf.write("\7\u00bc\2\2\u11b3\u11b2\3\2\2\2\u11b3\u11b4\3\2\2\2\u11b4") + buf.write("\u11b5\3\2\2\2\u11b5\u11b8\7\u0267\2\2\u11b6\u11b8\7\u00f4") + buf.write("\2\2\u11b7\u11b3\3\2\2\2\u11b7\u11b6\3\2\2\2\u11b8\u11c3") + buf.write("\3\2\2\2\u11b9\u11bb\7\u01bc\2\2\u11ba\u11b9\3\2\2\2\u11ba") + buf.write("\u11bb\3\2\2\2\u11bb\u11c1\3\2\2\2\u11bc\u11bd\7\u024b") + buf.write("\2\2\u11bd\u11be\5\u0192\u00ca\2\u11be\u11bf\7\u024c\2") + buf.write("\2\u11bf\u11c2\3\2\2\2\u11c0\u11c2\5\u0192\u00ca\2\u11c1") + buf.write("\u11bc\3\2\2\2\u11c1\u11c0\3\2\2\2\u11c2\u11c4\3\2\2\2") + buf.write("\u11c3\u11ba\3\2\2\2\u11c3\u11c4\3\2\2\2\u11c4\u0191\3") + buf.write("\2\2\2\u11c5\u11cc\5\u0194\u00cb\2\u11c6\u11c8\7\u0245") + buf.write("\2\2\u11c7\u11c6\3\2\2\2\u11c7\u11c8\3\2\2\2\u11c8\u11c9") + buf.write("\3\2\2\2\u11c9\u11cb\5\u0194\u00cb\2\u11ca\u11c7\3\2\2") + buf.write("\2\u11cb\u11ce\3\2\2\2\u11cc\u11ca\3\2\2\2\u11cc\u11cd") + buf.write("\3\2\2\2\u11cd\u0193\3\2\2\2\u11ce\u11cc\3\2\2\2\u11cf") + buf.write("\u11d1\7\u01d5\2\2\u11d0\u11cf\3\2\2\2\u11d0\u11d1\3\2") + buf.write("\2\2\u11d1\u11d2\3\2\2\2\u11d2\u120c\t=\2\2\u11d3\u11d5") + buf.write("\7\u00a0\2\2\u11d4\u11d6\5\u0240\u0121\2\u11d5\u11d4\3") + buf.write("\2\2\2\u11d5\u11d6\3\2\2\2\u11d6\u120c\3\2\2\2\u11d7\u11d9") + buf.write("\7\u015f\2\2\u11d8\u11da\5\u0240\u0121\2\u11d9\u11d8\3") + buf.write("\2\2\2\u11d9\u11da\3\2\2\2\u11da\u120c\3\2\2\2\u11db\u11dd") + buf.write("\7?\2\2\u11dc\u11de\7\u0176\2\2\u11dd\u11dc\3\2\2\2\u11dd") + buf.write("\u11de\3\2\2\2\u11de\u11df\3\2\2\2\u11df\u120c\7\u0267") + buf.write("\2\2\u11e0\u11e2\7\u01a1\2\2\u11e1\u11e3\7\u0176\2\2\u11e2") + buf.write("\u11e1\3\2\2\2\u11e2\u11e3\3\2\2\2\u11e3\u11e4\3\2\2\2") + buf.write("\u11e4\u120c\7\u0267\2\2\u11e5\u11e7\7e\2\2\u11e6\u11e8") + buf.write("\5\u0240\u0121\2\u11e7\u11e6\3\2\2\2\u11e7\u11e8\3\2\2") + buf.write("\2\u11e8\u120c\3\2\2\2\u11e9\u11ea\7\u00be\2\2\u11ea\u120c") + buf.write("\7\u0267\2\2\u11eb\u11ec\7O\2\2\u11ec\u120c\7\u0267\2") + buf.write("\2\u11ed\u11ee\7\\\2\2\u11ee\u11f1\7\u00be\2\2\u11ef\u11f2") + buf.write("\7\u024f\2\2\u11f0\u11f2\5\u02b6\u015c\2\u11f1\u11ef\3") + buf.write("\2\2\2\u11f1\u11f0\3\2\2\2\u11f2\u120c\3\2\2\2\u11f3\u11f9") + buf.write("\7\u01d4\2\2\u11f4\u11fa\7\u024f\2\2\u11f5\u11f6\7\u024b") + buf.write("\2\2\u11f6\u11f7\5\u02b6\u015c\2\u11f7\u11f8\7\u024c\2") + buf.write("\2\u11f8\u11fa\3\2\2\2\u11f9\u11f4\3\2\2\2\u11f9\u11f5") + buf.write("\3\2\2\2\u11fa\u120c\3\2\2\2\u11fb\u11fc\7\\\2\2\u11fc") + buf.write("\u11fd\7\u01a0\2\2\u11fd\u11fe\7\u01a1\2\2\u11fe\u120c") + buf.write("\5\u02b6\u015c\2\u11ff\u1200\7\u01d2\2\2\u1200\u1201\7") + buf.write("\u024b\2\2\u1201\u1202\5\u02b6\u015c\2\u1202\u1203\7\u024c") + buf.write("\2\2\u1203\u120c\3\2\2\2\u1204\u1205\7\u01d3\2\2\u1205") + buf.write("\u1206\7\u024b\2\2\u1206\u1207\5\u02b6\u015c\2\u1207\u1208") + buf.write("\7\u024c\2\2\u1208\u120c\3\2\2\2\u1209\u120a\7L\2\2\u120a") + buf.write("\u120c\7\u0267\2\2\u120b\u11d0\3\2\2\2\u120b\u11d3\3\2") + buf.write("\2\2\u120b\u11d7\3\2\2\2\u120b\u11db\3\2\2\2\u120b\u11e0") + buf.write("\3\2\2\2\u120b\u11e5\3\2\2\2\u120b\u11e9\3\2\2\2\u120b") + buf.write("\u11eb\3\2\2\2\u120b\u11ed\3\2\2\2\u120b\u11f3\3\2\2\2") + buf.write("\u120b\u11fb\3\2\2\2\u120b\u11ff\3\2\2\2\u120b\u1204\3") + buf.write("\2\2\2\u120b\u1209\3\2\2\2\u120c\u0195\3\2\2\2\u120d\u120e") + buf.write("\7\u01a5\2\2\u120e\u1210\7\u00cc\2\2\u120f\u120d\3\2\2") + buf.write("\2\u120f\u1210\3\2\2\2\u1210\u1212\3\2\2\2\u1211\u1213") + buf.write("\t\66\2\2\u1212\u1211\3\2\2\2\u1212\u1213\3\2\2\2\u1213") + buf.write("\u1215\3\2\2\2\u1214\u1216\7\u00c3\2\2\u1215\u1214\3\2") + buf.write("\2\2\u1215\u1216\3\2\2\2\u1216\u1218\3\2\2\2\u1217\u1219") + buf.write("\7\u008c\2\2\u1218\u1217\3\2\2\2\u1218\u1219\3\2\2\2\u1219") + buf.write("\u121a\3\2\2\2\u121a\u121c\7\u011a\2\2\u121b\u121d\5\u019a") + buf.write("\u00ce\2\u121c\u121b\3\2\2\2\u121c\u121d\3\2\2\2\u121d") + buf.write("\u121e\3\2\2\2\u121e\u1220\5\u026a\u0136\2\u121f\u1221") + buf.write("\5\u019c\u00cf\2\u1220\u121f\3\2\2\2\u1220\u1221\3\2\2") + buf.write("\2\u1221\u1224\3\2\2\2\u1222\u1223\7\u01b7\2\2\u1223\u1225") + buf.write("\5\u0210\u0109\2\u1224\u1222\3\2\2\2\u1224\u1225\3\2\2") + buf.write("\2\u1225\u1228\3\2\2\2\u1226\u1227\7\u01bc\2\2\u1227\u1229") + buf.write("\5\u01dc\u00ef\2\u1228\u1226\3\2\2\2\u1228\u1229\3\2\2") + buf.write("\2\u1229\u122b\3\2\2\2\u122a\u122c\5\u01e8\u00f5\2\u122b") + buf.write("\u122a\3\2\2\2\u122b\u122c\3\2\2\2\u122c\u122d\3\2\2\2") + buf.write("\u122d\u122e\7\u0176\2\2\u122e\u1230\5\u0270\u0139\2\u122f") + buf.write("\u1231\5\u019e\u00d0\2\u1230\u122f\3\2\2\2\u1230\u1231") + buf.write("\3\2\2\2\u1231\u1237\3\2\2\2\u1232\u1234\7\u01bc\2\2\u1233") + buf.write("\u1235\7\u0098\2\2\u1234\u1233\3\2\2\2\u1234\u1235\3\2") + buf.write("\2\2\u1235\u1236\3\2\2\2\u1236\u1238\7\66\2\2\u1237\u1232") + buf.write("\3\2\2\2\u1237\u1238\3\2\2\2\u1238\u0197\3\2\2\2\u1239") + buf.write("\u123a\7i\2\2\u123a\u123b\7\u0130\2\2\u123b\u0199\3\2") + buf.write("\2\2\u123c\u123d\7i\2\2\u123d\u123e\7\u01a0\2\2\u123e") + buf.write("\u123f\7\u0130\2\2\u123f\u019b\3\2\2\2\u1240\u1241\7\u024b") + buf.write("\2\2\u1241\u1246\5\u0210\u0109\2\u1242\u1243\7\u0245\2") + buf.write("\2\u1243\u1245\5\u0210\u0109\2\u1244\u1242\3\2\2\2\u1245") + buf.write("\u1248\3\2\2\2\u1246\u1244\3\2\2\2\u1246\u1247\3\2\2\2") + buf.write("\u1247\u1249\3\2\2\2\u1248\u1246\3\2\2\2\u1249\u124a\7") + buf.write("\u024c\2\2\u124a\u019d\3\2\2\2\u124b\u124d\7\u01bc\2\2") + buf.write("\u124c\u124e\t>\2\2\u124d\u124c\3\2\2\2\u124d\u124e\3") + buf.write("\2\2\2\u124e\u124f\3\2\2\2\u124f\u1250\7\u017c\2\2\u1250") + buf.write("\u1251\7\u00a3\2\2\u1251\u019f\3\2\2\2\u1252\u1254\t?") + buf.write("\2\2\u1253\u1252\3\2\2\2\u1253\u1254\3\2\2\2\u1254\u1255") + buf.write("\3\2\2\2\u1255\u1258\t\66\2\2\u1256\u1258\7\u0110\2\2") + buf.write("\u1257\u1253\3\2\2\2\u1257\u1256\3\2\2\2\u1257\u1258\3") + buf.write("\2\2\2\u1258\u1259\3\2\2\2\u1259\u125b\7\u01af\2\2\u125a") + buf.write("\u125c\5\u019a\u00ce\2\u125b\u125a\3\2\2\2\u125b\u125c") + buf.write("\3\2\2\2\u125c\u125d\3\2\2\2\u125d\u125e\5\u026a\u0136") + buf.write("\2\u125e\u1260\5\u01a6\u00d4\2\u125f\u1261\5\u01b4\u00db") + buf.write("\2\u1260\u125f\3\2\2\2\u1260\u1261\3\2\2\2\u1261\u1264") + buf.write("\3\2\2\2\u1262\u1263\7\u01b7\2\2\u1263\u1265\5\u0210\u0109") + buf.write("\2\u1264\u1262\3\2\2\2\u1264\u1265\3\2\2\2\u1265\u1267") + buf.write("\3\2\2\2\u1266\u1268\5\u01e4\u00f3\2\u1267\u1266\3\2\2") + buf.write("\2\u1267\u1268\3\2\2\2\u1268\u126a\3\2\2\2\u1269\u126b") + buf.write("\5\u01e6\u00f4\2\u126a\u1269\3\2\2\2\u126a\u126b\3\2\2") + buf.write("\2\u126b\u126d\3\2\2\2\u126c\u126e\5\u01e8\u00f5\2\u126d") + buf.write("\u126c\3\2\2\2\u126d\u126e\3\2\2\2\u126e\u01a1\3\2\2\2") + buf.write("\u126f\u1271\t?\2\2\u1270\u126f\3\2\2\2\u1270\u1271\3") + buf.write("\2\2\2\u1271\u1272\3\2\2\2\u1272\u1275\t\66\2\2\u1273") + buf.write("\u1275\7\u0110\2\2\u1274\u1270\3\2\2\2\u1274\u1273\3\2") + buf.write("\2\2\u1274\u1275\3\2\2\2\u1275\u1276\3\2\2\2\u1276\u1278") + buf.write("\7\u01af\2\2\u1277\u1279\5\u019a\u00ce\2\u1278\u1277\3") + buf.write("\2\2\2\u1278\u1279\3\2\2\2\u1279\u127a\3\2\2\2\u127a\u127c") + buf.write("\5\u026a\u0136\2\u127b\u127d\5\u01d8\u00ed\2\u127c\u127b") + buf.write("\3\2\2\2\u127c\u127d\3\2\2\2\u127d\u1280\3\2\2\2\u127e") + buf.write("\u127f\7\u01b7\2\2\u127f\u1281\5\u0210\u0109\2\u1280\u127e") + buf.write("\3\2\2\2\u1280\u1281\3\2\2\2\u1281\u1283\3\2\2\2\u1282") + buf.write("\u1284\5\u01e4\u00f3\2\u1283\u1282\3\2\2\2\u1283\u1284") + buf.write("\3\2\2\2\u1284\u1286\3\2\2\2\u1285\u1287\5\u01e6\u00f4") + buf.write("\2\u1286\u1285\3\2\2\2\u1286\u1287\3\2\2\2\u1287\u1289") + buf.write("\3\2\2\2\u1288\u128a\5\u01e8\u00f5\2\u1289\u1288\3\2\2") + buf.write("\2\u1289\u128a\3\2\2\2\u128a\u128b\3\2\2\2\u128b\u128f") + buf.write("\7\u0176\2\2\u128c\u1290\5\u0270\u0139\2\u128d\u128e\7") + buf.write("T\2\2\u128e\u1290\5\u0246\u0124\2\u128f\u128c\3\2\2\2") + buf.write("\u128f\u128d\3\2\2\2\u1290\u1296\3\2\2\2\u1291\u1293\7") + buf.write("\u01bc\2\2\u1292\u1294\7\u0098\2\2\u1293\u1292\3\2\2\2") + buf.write("\u1293\u1294\3\2\2\2\u1294\u1295\3\2\2\2\u1295\u1297\7") + buf.write("\66\2\2\u1296\u1291\3\2\2\2\u1296\u1297\3\2\2\2\u1297") + buf.write("\u01a3\3\2\2\2\u1298\u1299\7\u0192\2\2\u1299\u129b\7\u01af") + buf.write("\2\2\u129a\u129c\5\u019a\u00ce\2\u129b\u129a\3\2\2\2\u129b") + buf.write("\u129c\3\2\2\2\u129c\u129d\3\2\2\2\u129d\u12a0\5\u026a") + buf.write("\u0136\2\u129e\u12a1\5\u01b0\u00d9\2\u129f\u12a1\5\u01a8") + buf.write("\u00d5\2\u12a0\u129e\3\2\2\2\u12a0\u129f\3\2\2\2\u12a1") + buf.write("\u12a2\3\2\2\2\u12a2\u12a3\5\u01ba\u00de\2\u12a3\u01a5") + buf.write("\3\2\2\2\u12a4\u12a8\5\u01b0\u00d9\2\u12a5\u12a8\5\u01b2") + buf.write("\u00da\2\u12a6\u12a8\5\u01a8\u00d5\2\u12a7\u12a4\3\2\2") + buf.write("\2\u12a7\u12a5\3\2\2\2\u12a7\u12a6\3\2\2\2\u12a8\u01a7") + buf.write("\3\2\2\2\u12a9\u12aa\7\u00ae\2\2\u12aa\u12ab\7\u009e\2") + buf.write("\2\u12ab\u12ad\5\u026a\u0136\2\u12ac\u12ae\5\u01c2\u00e2") + buf.write("\2\u12ad\u12ac\3\2\2\2\u12ad\u12ae\3\2\2\2\u12ae\u12af") + buf.write("\3\2\2\2\u12af\u12b0\5\u01aa\u00d6\2\u12b0\u01a9\3\2\2") + buf.write("\2\u12b1\u12b2\7\u0191\2\2\u12b2\u12b3\7\u014c\2\2\u12b3") + buf.write("\u12b6\5\u01ac\u00d7\2\u12b4\u12b6\7\u0187\2\2\u12b5\u12b1") + buf.write("\3\2\2\2\u12b5\u12b4\3\2\2\2\u12b6\u01ab\3\2\2\2\u12b7") + buf.write("\u12b8\7\u0197\2\2\u12b8\u12b9\7\u024b\2\2\u12b9\u12be") + buf.write("\5\u0230\u0119\2\u12ba\u12bb\7\u0245\2\2\u12bb\u12bd\5") + buf.write("\u0230\u0119\2\u12bc\u12ba\3\2\2\2\u12bd\u12c0\3\2\2\2") + buf.write("\u12be\u12bc\3\2\2\2\u12be\u12bf\3\2\2\2\u12bf\u12c1\3") + buf.write("\2\2\2\u12c0\u12be\3\2\2\2\u12c1\u12c2\7\u024c\2\2\u12c2") + buf.write("\u12d1\3\2\2\2\u12c3\u12c4\7\u0193\2\2\u12c4\u12c5\5\u01ae") + buf.write("\u00d8\2\u12c5\u12c6\7\u01b1\2\2\u12c6\u12c7\5\u01ae\u00d8") + buf.write("\2\u12c7\u12d1\3\2\2\2\u12c8\u12c9\7\u01bc\2\2\u12c9\u12ca") + buf.write("\7\u024b\2\2\u12ca\u12cb\7\u01ef\2\2\u12cb\u12cc\7\u0262") + buf.write("\2\2\u12cc\u12cd\7\u0245\2\2\u12cd\u12ce\7\u0205\2\2\u12ce") + buf.write("\u12cf\7\u0262\2\2\u12cf\u12d1\7\u024c\2\2\u12d0\u12b7") + buf.write("\3\2\2\2\u12d0\u12c3\3\2\2\2\u12d0\u12c8\3\2\2\2\u12d1") + buf.write("\u01ad\3\2\2\2\u12d2\u12d3\7\u024b\2\2\u12d3\u12d8\5\u0230") + buf.write("\u0119\2\u12d4\u12d5\7\u0245\2\2\u12d5\u12d7\5\u0230\u0119") + buf.write("\2\u12d6\u12d4\3\2\2\2\u12d7\u12da\3\2\2\2\u12d8\u12d6") + buf.write("\3\2\2\2\u12d8\u12d9\3\2\2\2\u12d9\u12db\3\2\2\2\u12da") + buf.write("\u12d8\3\2\2\2\u12db\u12dc\7\u024c\2\2\u12dc\u01af\3\2") + buf.write("\2\2\u12dd\u12e6\7\u024b\2\2\u12de\u12e3\5\u01c4\u00e3") + buf.write("\2\u12df\u12e0\7\u0245\2\2\u12e0\u12e2\5\u01c4\u00e3\2") + buf.write("\u12e1\u12df\3\2\2\2\u12e2\u12e5\3\2\2\2\u12e3\u12e1\3") + buf.write("\2\2\2\u12e3\u12e4\3\2\2\2\u12e4\u12e7\3\2\2\2\u12e5\u12e3") + buf.write("\3\2\2\2\u12e6\u12de\3\2\2\2\u12e6\u12e7\3\2\2\2\u12e7") + buf.write("\u12e8\3\2\2\2\u12e8\u12eb\7\u024c\2\2\u12e9\u12ea\7t") + buf.write("\2\2\u12ea\u12ec\5\u01d8\u00ed\2\u12eb\u12e9\3\2\2\2\u12eb") + buf.write("\u12ec\3\2\2\2\u12ec\u01b1\3\2\2\2\u12ed\u12ee\7\u009e") + buf.write("\2\2\u12ee\u12f0\5\u0224\u0113\2\u12ef\u12f1\5\u01c2\u00e2") + buf.write("\2\u12f0\u12ef\3\2\2\2\u12f0\u12f1\3\2\2\2\u12f1\u01b3") + buf.write("\3\2\2\2\u12f2\u12f3\7\u00ae\2\2\u12f3\u12f4\7\26\2\2") + buf.write("\u12f4\u12f5\5\u01b6\u00dc\2\u12f5\u01b5\3\2\2\2\u12f6") + buf.write("\u12f7\t@\2\2\u12f7\u12f8\7\u024b\2\2\u12f8\u12fd\5\u01b8") + buf.write("\u00dd\2\u12f9\u12fa\7\u0245\2\2\u12fa\u12fc\5\u01b8\u00dd") + buf.write("\2\u12fb\u12f9\3\2\2\2\u12fc\u12ff\3\2\2\2\u12fd\u12fb") + buf.write("\3\2\2\2\u12fd\u12fe\3\2\2\2\u12fe\u1300\3\2\2\2\u12ff") + buf.write("\u12fd\3\2\2\2\u1300\u1301\7\u024c\2\2\u1301\u01b7\3\2") + buf.write("\2\2\u1302\u1304\5\u0230\u0119\2\u1303\u1305\5\u0210\u0109") + buf.write("\2\u1304\u1303\3\2\2\2\u1304\u1305\3\2\2\2\u1305\u01b9") + buf.write("\3\2\2\2\u1306\u1307\7\u00e4\2\2\u1307\u1309\5\u0210\u0109") + buf.write("\2\u1308\u130a\5\u01bc\u00df\2\u1309\u1308\3\2\2\2\u1309") + buf.write("\u130a\3\2\2\2\u130a\u01bb\3\2\2\2\u130b\u130c\7\u00a4") + buf.write("\2\2\u130c\u130d\7\u024b\2\2\u130d\u1312\5\u01be\u00e0") + buf.write("\2\u130e\u130f\7\u0245\2\2\u130f\u1311\5\u01be\u00e0\2") + buf.write("\u1310\u130e\3\2\2\2\u1311\u1314\3\2\2\2\u1312\u1310\3") + buf.write("\2\2\2\u1312\u1313\3\2\2\2\u1313\u1315\3\2\2\2\u1314\u1312") + buf.write("\3\2\2\2\u1315\u1316\7\u024c\2\2\u1316\u01bd\3\2\2\2\u1317") + buf.write("\u1319\t<\2\2\u1318\u1317\3\2\2\2\u1318\u1319\3\2\2\2") + buf.write("\u1319\u131a\3\2\2\2\u131a\u131c\5\u01c0\u00e1\2\u131b") + buf.write("\u131d\5\u0146\u00a4\2\u131c\u131b\3\2\2\2\u131c\u131d") + buf.write("\3\2\2\2\u131d\u01bf\3\2\2\2\u131e\u1321\5\u0210\u0109") + buf.write("\2\u131f\u1321\7\u01b6\2\2\u1320\u131e\3\2\2\2\u1320\u131f") + buf.write("\3\2\2\2\u1321\u01c1\3\2\2\2\u1322\u1323\7\u024b\2\2\u1323") + buf.write("\u1328\5\u01c6\u00e4\2\u1324\u1325\7\u0245\2\2\u1325\u1327") + buf.write("\5\u01c6\u00e4\2\u1326\u1324\3\2\2\2\u1327\u132a\3\2\2") + buf.write("\2\u1328\u1326\3\2\2\2\u1328\u1329\3\2\2\2\u1329\u132b") + buf.write("\3\2\2\2\u132a\u1328\3\2\2\2\u132b\u132c\7\u024c\2\2\u132c") + buf.write("\u01c3\3\2\2\2\u132d\u1338\5\u01c8\u00e5\2\u132e\u1338") + buf.write("\5\u01cc\u00e7\2\u132f\u1330\7\u0167\2\2\u1330\u1334\5") + buf.write("\u026a\u0136\2\u1331\u1333\5\u01ca\u00e6\2\u1332\u1331") + buf.write("\3\2\2\2\u1333\u1336\3\2\2\2\u1334\u1332\3\2\2\2\u1334") + buf.write("\u1335\3\2\2\2\u1335\u1338\3\2\2\2\u1336\u1334\3\2\2\2") + buf.write("\u1337\u132d\3\2\2\2\u1337\u132e\3\2\2\2\u1337\u132f\3") + buf.write("\2\2\2\u1338\u01c5\3\2\2\2\u1339\u133c\5\u0210\u0109\2") + buf.write("\u133a\u133b\7\u01bc\2\2\u133b\u133d\7\u00a4\2\2\u133c") + buf.write("\u133a\3\2\2\2\u133c\u133d\3\2\2\2\u133d\u1341\3\2\2\2") + buf.write("\u133e\u1340\5\u01cc\u00e7\2\u133f\u133e\3\2\2\2\u1340") + buf.write("\u1343\3\2\2\2\u1341\u133f\3\2\2\2\u1341\u1342\3\2\2\2") + buf.write("\u1342\u1346\3\2\2\2\u1343\u1341\3\2\2\2\u1344\u1346\5") + buf.write("\u01cc\u00e7\2\u1345\u1339\3\2\2\2\u1345\u1344\3\2\2\2") + buf.write("\u1346\u01c7\3\2\2\2\u1347\u1348\5\u0210\u0109\2\u1348") + buf.write("\u134a\5\u0224\u0113\2\u1349\u134b\5\u01bc\u00df\2\u134a") + buf.write("\u1349\3\2\2\2\u134a\u134b\3\2\2\2\u134b\u134d\3\2\2\2") + buf.write("\u134c\u134e\5\u01fa\u00fe\2\u134d\u134c\3\2\2\2\u134d") + buf.write("\u134e\3\2\2\2\u134e\u1352\3\2\2\2\u134f\u1351\5\u01cc") + buf.write("\u00e7\2\u1350\u134f\3\2\2\2\u1351\u1354\3\2\2\2\u1352") + buf.write("\u1350\3\2\2\2\u1352\u1353\3\2\2\2\u1353\u01c9\3\2\2\2") + buf.write("\u1354\u1352\3\2\2\2\u1355\u1356\tA\2\2\u1356\u1357\t") + buf.write("B\2\2\u1357\u01cb\3\2\2\2\u1358\u1359\7\u017f\2\2\u1359") + buf.write("\u135b\5\u0210\u0109\2\u135a\u1358\3\2\2\2\u135a\u135b") + buf.write("\3\2\2\2\u135b\u135c\3\2\2\2\u135c\u135e\5\u01ce\u00e8") + buf.write("\2\u135d\u135f\5d\63\2\u135e\u135d\3\2\2\2\u135e\u135f") + buf.write("\3\2\2\2\u135f\u1361\3\2\2\2\u1360\u1362\5f\64\2\u1361") + buf.write("\u1360\3\2\2\2\u1361\u1362\3\2\2\2\u1362\u01cd\3\2\2\2") + buf.write("\u1363\u1366\7Q\2\2\u1364\u1365\7\u01b7\2\2\u1365\u1367") + buf.write("\5\u0210\u0109\2\u1366\u1364\3\2\2\2\u1366\u1367\3\2\2") + buf.write("\2\u1367\u1368\3\2\2\2\u1368\u1369\7\u024b\2\2\u1369\u136a") + buf.write("\5\u029c\u014f\2\u136a\u136b\7\u01bc\2\2\u136b\u1373\5") + buf.write("\u01d0\u00e9\2\u136c\u136d\7\u0245\2\2\u136d\u136e\5\u029c") + buf.write("\u014f\2\u136e\u136f\7\u01bc\2\2\u136f\u1370\5\u01d0\u00e9") + buf.write("\2\u1370\u1372\3\2\2\2\u1371\u136c\3\2\2\2\u1372\u1375") + buf.write("\3\2\2\2\u1373\u1371\3\2\2\2\u1373\u1374\3\2\2\2\u1374") + buf.write("\u1376\3\2\2\2\u1375\u1373\3\2\2\2\u1376\u1377\7\u024c") + buf.write("\2\2\u1377\u137a\5\u01d6\u00ec\2\u1378\u1379\7\u01ba\2") + buf.write("\2\u1379\u137b\5\u0230\u0119\2\u137a\u1378\3\2\2\2\u137a") + buf.write("\u137b\3\2\2\2\u137b\u13b1\3\2\2\2\u137c\u137d\7\u0192") + buf.write("\2\2\u137d\u137e\7|\2\2\u137e\u1380\5\u01d8\u00ed\2\u137f") + buf.write("\u137c\3\2\2\2\u137f\u1380\3\2\2\2\u1380\u1381\3\2\2\2") + buf.write("\u1381\u1382\7\u01a9\2\2\u1382\u1384\5\u026a\u0136\2\u1383") + buf.write("\u1385\5\u01d8\u00ed\2\u1384\u1383\3\2\2\2\u1384\u1385") + buf.write("\3\2\2\2\u1385\u138d\3\2\2\2\u1386\u1387\7\u008b\2\2\u1387") + buf.write("\u138c\tC\2\2\u1388\u1389\7\u01a3\2\2\u1389\u138a\tD\2") + buf.write("\2\u138a\u138c\5\u01ea\u00f6\2\u138b\u1386\3\2\2\2\u138b") + buf.write("\u1388\3\2\2\2\u138c\u138f\3\2\2\2\u138d\u138b\3\2\2\2") + buf.write("\u138d\u138e\3\2\2\2\u138e\u13b1\3\2\2\2\u138f\u138d\3") + buf.write("\2\2\2\u1390\u1391\7\u017c\2\2\u1391\u1392\7\u024b\2\2") + buf.write("\u1392\u1393\5\u0230\u0119\2\u1393\u1396\7\u024c\2\2\u1394") + buf.write("\u1395\7\u0098\2\2\u1395\u1397\7s\2\2\u1396\u1394\3\2") + buf.write("\2\2\u1396\u1397\3\2\2\2\u1397\u13b1\3\2\2\2\u1398\u139a") + buf.write("\7\u01a0\2\2\u1399\u1398\3\2\2\2\u1399\u139a\3\2\2\2\u139a") + buf.write("\u139b\3\2\2\2\u139b\u13b1\7\u01a1\2\2\u139c\u13a0\7\u01b5") + buf.write("\2\2\u139d\u139e\7\u01a8\2\2\u139e\u13a0\7|\2\2\u139f") + buf.write("\u139c\3\2\2\2\u139f\u139d\3\2\2\2\u13a0\u13a2\3\2\2\2") + buf.write("\u13a1\u13a3\5\u01d8\u00ed\2\u13a2\u13a1\3\2\2\2\u13a2") + buf.write("\u13a3\3\2\2\2\u13a3\u13a4\3\2\2\2\u13a4\u13b1\5\u01d6") + buf.write("\u00ec\2\u13a5\u13a6\7\u0187\2\2\u13a6\u13b1\5\u0230\u0119") + buf.write("\2\u13a7\u13b1\5Z.\2\u13a8\u13a9\7`\2\2\u13a9\u13aa\7") + buf.write("\r\2\2\u13aa\u13ab\7\u0176\2\2\u13ab\u13ac\7\u024b\2\2") + buf.write("\u13ac\u13ad\5\u0230\u0119\2\u13ad\u13ae\7\u024c\2\2\u13ae") + buf.write("\u13af\7\u00f6\2\2\u13af\u13b1\3\2\2\2\u13b0\u1363\3\2") + buf.write("\2\2\u13b0\u137f\3\2\2\2\u13b0\u1390\3\2\2\2\u13b0\u1399") + buf.write("\3\2\2\2\u13b0\u139f\3\2\2\2\u13b0\u13a5\3\2\2\2\u13b0") + buf.write("\u13a7\3\2\2\2\u13b0\u13a8\3\2\2\2\u13b1\u01cf\3\2\2\2") + buf.write("\u13b2\u13c0\5\u0234\u011b\2\u13b3\u13c0\7\u0242\2\2\u13b4") + buf.write("\u13c0\7\u0246\2\2\u13b5\u13c0\7\u0247\2\2\u13b6\u13c0") + buf.write("\7\u0248\2\2\u13b7\u13c0\7\u0249\2\2\u13b8\u13c0\7\u024a") + buf.write("\2\2\u13b9\u13c0\7\u024d\2\2\u13ba\u13c0\7\u024e\2\2\u13bb") + buf.write("\u13c0\7\u024f\2\2\u13bc\u13c0\7\u0250\2\2\u13bd\u13c0") + buf.write("\7\u0251\2\2\u13be\u13c0\7\u0252\2\2\u13bf\u13b2\3\2\2") + buf.write("\2\u13bf\u13b3\3\2\2\2\u13bf\u13b4\3\2\2\2\u13bf\u13b5") + buf.write("\3\2\2\2\u13bf\u13b6\3\2\2\2\u13bf\u13b7\3\2\2\2\u13bf") + buf.write("\u13b8\3\2\2\2\u13bf\u13b9\3\2\2\2\u13bf\u13ba\3\2\2\2") + buf.write("\u13bf\u13bb\3\2\2\2\u13bf\u13bc\3\2\2\2\u13bf\u13bd\3") + buf.write("\2\2\2\u13bf\u13be\3\2\2\2\u13c0\u01d1\3\2\2\2\u13c1\u13cf") + buf.write("\5\u01d4\u00eb\2\u13c2\u13cf\7\u0242\2\2\u13c3\u13cf\7") + buf.write("\u0246\2\2\u13c4\u13cf\7\u0247\2\2\u13c5\u13cf\7\u0248") + buf.write("\2\2\u13c6\u13cf\7\u0249\2\2\u13c7\u13cf\7\u024a\2\2\u13c8") + buf.write("\u13cf\7\u024d\2\2\u13c9\u13cf\7\u024e\2\2\u13ca\u13cf") + buf.write("\7\u024f\2\2\u13cb\u13cf\7\u0250\2\2\u13cc\u13cf\7\u0251") + buf.write("\2\2\u13cd\u13cf\7\u0252\2\2\u13ce\u13c1\3\2\2\2\u13ce") + buf.write("\u13c2\3\2\2\2\u13ce\u13c3\3\2\2\2\u13ce\u13c4\3\2\2\2") + buf.write("\u13ce\u13c5\3\2\2\2\u13ce\u13c6\3\2\2\2\u13ce\u13c7\3") + buf.write("\2\2\2\u13ce\u13c8\3\2\2\2\u13ce\u13c9\3\2\2\2\u13ce\u13ca") + buf.write("\3\2\2\2\u13ce\u13cb\3\2\2\2\u13ce\u13cc\3\2\2\2\u13ce") + buf.write("\u13cd\3\2\2\2\u13cf\u01d3\3\2\2\2\u13d0\u13d1\tE\2\2") + buf.write("\u13d1\u01d5\3\2\2\2\u13d2\u13d4\5\u0096L\2\u13d3\u13d2") + buf.write("\3\2\2\2\u13d3\u13d4\3\2\2\2\u13d4\u13d6\3\2\2\2\u13d5") + buf.write("\u13d7\5\u01e2\u00f2\2\u13d6\u13d5\3\2\2\2\u13d6\u13d7") + buf.write("\3\2\2\2\u13d7\u13de\3\2\2\2\u13d8\u13d9\7\u01b7\2\2\u13d9") + buf.write("\u13dc\7q\2\2\u13da\u13dd\5\u01e8\u00f5\2\u13db\u13dd") + buf.write("\5\u026a\u0136\2\u13dc\u13da\3\2\2\2\u13dc\u13db\3\2\2") + buf.write("\2\u13dd\u13df\3\2\2\2\u13de\u13d8\3\2\2\2\u13de\u13df") + buf.write("\3\2\2\2\u13df\u01d7\3\2\2\2\u13e0\u13e1\7\u024b\2\2\u13e1") + buf.write("\u13e2\5\u01da\u00ee\2\u13e2\u13e3\7\u024c\2\2\u13e3\u01d9") + buf.write("\3\2\2\2\u13e4\u13e9\5\u026a\u0136\2\u13e5\u13e6\7\u0245") + buf.write("\2\2\u13e6\u13e8\5\u026a\u0136\2\u13e7\u13e5\3\2\2\2\u13e8") + buf.write("\u13eb\3\2\2\2\u13e9\u13e7\3\2\2\2\u13e9\u13ea\3\2\2\2") + buf.write("\u13ea\u01db\3\2\2\2\u13eb\u13e9\3\2\2\2\u13ec\u13ed\7") + buf.write("\u024b\2\2\u13ed\u13f2\5\u01de\u00f0\2\u13ee\u13ef\7\u0245") + buf.write("\2\2\u13ef\u13f1\5\u01de\u00f0\2\u13f0\u13ee\3\2\2\2\u13f1") + buf.write("\u13f4\3\2\2\2\u13f2\u13f0\3\2\2\2\u13f2\u13f3\3\2\2\2") + buf.write("\u13f3\u13f5\3\2\2\2\u13f4\u13f2\3\2\2\2\u13f5\u13f6\7") + buf.write("\u024c\2\2\u13f6\u01dd\3\2\2\2\u13f7\u13fa\5\u01e0\u00f1") + buf.write("\2\u13f8\u13f9\7\u0242\2\2\u13f9\u13fb\5\u0230\u0119\2") + buf.write("\u13fa\u13f8\3\2\2\2\u13fa\u13fb\3\2\2\2\u13fb\u01df\3") + buf.write("\2\2\2\u13fc\u13ff\5\u0214\u010b\2\u13fd\u13fe\7\u0253") + buf.write("\2\2\u13fe\u1400\5\u0214\u010b\2\u13ff\u13fd\3\2\2\2\u13ff") + buf.write("\u1400\3\2\2\2\u1400\u01e1\3\2\2\2\u1401\u1402\7\u01bc") + buf.write("\2\2\u1402\u1403\5\u01dc\u00ef\2\u1403\u01e3\3\2\2\2\u1404") + buf.write("\u140a\5\u01e2\u00f2\2\u1405\u1406\7\u01bc\2\2\u1406\u140a") + buf.write("\7\u00a0\2\2\u1407\u1408\7\u011f\2\2\u1408\u140a\7\u00a0") + buf.write("\2\2\u1409\u1404\3\2\2\2\u1409\u1405\3\2\2\2\u1409\u1407") + buf.write("\3\2\2\2\u140a\u01e5\3\2\2\2\u140b\u140c\7\u01a3\2\2\u140c") + buf.write("\u1412\7&\2\2\u140d\u140e\7\u00b6\2\2\u140e\u1413\7\u00d8") + buf.write("\2\2\u140f\u1410\7>\2\2\u1410\u1413\7\u00d8\2\2\u1411") + buf.write("\u1413\7I\2\2\u1412\u140d\3\2\2\2\u1412\u140f\3\2\2\2") + buf.write("\u1412\u1411\3\2\2\2\u1413\u01e7\3\2\2\2\u1414\u1415\7") + buf.write("\u00fe\2\2\u1415\u1416\5\u0210\u0109\2\u1416\u01e9\3\2") + buf.write("\2\2\u1417\u141d\5\u01f8\u00fd\2\u1418\u1419\7\u00e6\2") + buf.write("\2\u1419\u141d\tF\2\2\u141a\u141b\7\u0098\2\2\u141b\u141d") + buf.write("\7\6\2\2\u141c\u1417\3\2\2\2\u141c\u1418\3\2\2\2\u141c") + buf.write("\u141a\3\2\2\2\u141d\u01eb\3\2\2\2\u141e\u141f\7\u00aa") + buf.write("\2\2\u141f\u1423\7\u01b1\2\2\u1420\u1424\5\u0210\u0109") + buf.write("\2\u1421\u1424\7\u0186\2\2\u1422\u1424\7\u01ac\2\2\u1423") + buf.write("\u1420\3\2\2\2\u1423\u1421\3\2\2\2\u1423\u1422\3\2\2\2") + buf.write("\u1424\u01ed\3\2\2\2\u1425\u1426\7\u00ca\2\2\u1426\u1427") + buf.write("\7\u01b1\2\2\u1427\u1428\5\u0210\u0109\2\u1428\u01ef\3") + buf.write("\2\2\2\u1429\u142a\7\u00e6\2\2\u142a\u142b\7\u00db\2\2") + buf.write("\u142b\u142c\5\u0210\u0109\2\u142c\u01f1\3\2\2\2\u142d") + buf.write("\u1439\7\u01ab\2\2\u142e\u1439\7x\2\2\u142f\u1439\7\u0112") + buf.write("\2\2\u1430\u1439\7>\2\2\u1431\u1439\7\u0107\2\2\u1432") + buf.write("\u1439\7\u01a9\2\2\u1433\u1439\7\u0106\2\2\u1434\u1436") + buf.write("\7\u0170\2\2\u1435\u1437\7\u00b8\2\2\u1436\u1435\3\2\2") + buf.write("\2\u1436\u1437\3\2\2\2\u1437\u1439\3\2\2\2\u1438\u142d") + buf.write("\3\2\2\2\u1438\u142e\3\2\2\2\u1438\u142f\3\2\2\2\u1438") + buf.write("\u1430\3\2\2\2\u1438\u1431\3\2\2\2\u1438\u1432\3\2\2\2") + buf.write("\u1438\u1433\3\2\2\2\u1438\u1434\3\2\2\2\u1439\u01f3\3") + buf.write("\2\2\2\u143a\u143b\tG\2\2\u143b\u01f5\3\2\2\2\u143c\u143d") + buf.write("\7\u00ae\2\2\u143d\u143e\7\26\2\2\u143e\u1443\5\u0230") + buf.write("\u0119\2\u143f\u1440\7\u0245\2\2\u1440\u1442\5\u0230\u0119") + buf.write("\2\u1441\u143f\3\2\2\2\u1442\u1445\3\2\2\2\u1443\u1441") + buf.write("\3\2\2\2\u1443\u1444\3\2\2\2\u1444\u01f7\3\2\2\2\u1445") + buf.write("\u1443\3\2\2\2\u1446\u1447\tH\2\2\u1447\u01f9\3\2\2\2") + buf.write("\u1448\u1449\7\u017d\2\2\u1449\u144a\5\u026a\u0136\2\u144a") + buf.write("\u01fb\3\2\2\2\u144b\u144e\5\u0210\u0109\2\u144c\u144e") + buf.write("\5\u01fe\u0100\2\u144d\u144b\3\2\2\2\u144d\u144c\3\2\2") + buf.write("\2\u144e\u1450\3\2\2\2\u144f\u1451\5\u0200\u0101\2\u1450") + buf.write("\u144f\3\2\2\2\u1450\u1451\3\2\2\2\u1451\u01fd\3\2\2\2") + buf.write("\u1452\u1453\7\u0264\2\2\u1453\u01ff\3\2\2\2\u1454\u1456") + buf.write("\5\u0202\u0102\2\u1455\u1454\3\2\2\2\u1456\u1457\3\2\2") + buf.write("\2\u1457\u1455\3\2\2\2\u1457\u1458\3\2\2\2\u1458\u1462") + buf.write("\3\2\2\2\u1459\u145b\5\u0202\u0102\2\u145a\u1459\3\2\2") + buf.write("\2\u145b\u145e\3\2\2\2\u145c\u145a\3\2\2\2\u145c\u145d") + buf.write("\3\2\2\2\u145d\u145f\3\2\2\2\u145e\u145c\3\2\2\2\u145f") + buf.write("\u1460\7\u0253\2\2\u1460\u1462\7\u024f\2\2\u1461\u1455") + buf.write("\3\2\2\2\u1461\u145c\3\2\2\2\u1462\u0201\3\2\2\2\u1463") + buf.write("\u1464\7\u0253\2\2\u1464\u1473\5\u0214\u010b\2\u1465\u1466") + buf.write("\7\u0257\2\2\u1466\u1467\5\u0230\u0119\2\u1467\u1468\7") + buf.write("\u0258\2\2\u1468\u1473\3\2\2\2\u1469\u146b\7\u0257\2\2") + buf.write("\u146a\u146c\5\u0230\u0119\2\u146b\u146a\3\2\2\2\u146b") + buf.write("\u146c\3\2\2\2\u146c\u146d\3\2\2\2\u146d\u146f\7\u0243") + buf.write("\2\2\u146e\u1470\5\u0230\u0119\2\u146f\u146e\3\2\2\2\u146f") + buf.write("\u1470\3\2\2\2\u1470\u1471\3\2\2\2\u1471\u1473\7\u0258") + buf.write("\2\2\u1472\u1463\3\2\2\2\u1472\u1465\3\2\2\2\u1472\u1469") + buf.write("\3\2\2\2\u1473\u0203\3\2\2\2\u1474\u1476\t#\2\2\u1475") + buf.write("\u1477\5\u0198\u00cd\2\u1476\u1475\3\2\2\2\u1476\u1477") + buf.write("\3\2\2\2\u1477\u1478\3\2\2\2\u1478\u147a\5\u026a\u0136") + buf.write("\2\u1479\u147b\5\u0142\u00a2\2\u147a\u1479\3\2\2\2\u147a") + buf.write("\u147b\3\2\2\2\u147b\u147d\3\2\2\2\u147c\u147e\5\u01f8") + buf.write("\u00fd\2\u147d\u147c\3\2\2\2\u147d\u147e\3\2\2\2\u147e") + buf.write("\u0205\3\2\2\2\u147f\u1481\7\u0106\2\2\u1480\u1482\5\u0198") + buf.write("\u00cd\2\u1481\u1480\3\2\2\2\u1481\u1482\3\2\2\2\u1482") + buf.write("\u1483\3\2\2\2\u1483\u1484\5\u0210\u0109\2\u1484\u1485") + buf.write("\7\u01a3\2\2\u1485\u1487\5\u026a\u0136\2\u1486\u1488\5") + buf.write("\u01f8\u00fd\2\u1487\u1486\3\2\2\2\u1487\u1488\3\2\2\2") + buf.write("\u1488\u0207\3\2\2\2\u1489\u148b\7\u00d9\2\2\u148a\u148c") + buf.write("\5\u0198\u00cd\2\u148b\u148a\3\2\2\2\u148b\u148c\3\2\2") + buf.write("\2\u148c\u148d\3\2\2\2\u148d\u148e\5\u0210\u0109\2\u148e") + buf.write("\u148f\7\u01a3\2\2\u148f\u1491\5\u026a\u0136\2\u1490\u1492") + buf.write("\5\u01f8\u00fd\2\u1491\u1490\3\2\2\2\u1491\u1492\3\2\2") + buf.write("\2\u1492\u0209\3\2\2\2\u1493\u1494\7\5\2\2\u1494\u14be") + buf.write("\7\u008e\2\2\u1495\u14be\7\u015b\2\2\u1496\u14be\7.\2") + buf.write("\2\u1497\u14be\7\67\2\2\u1498\u14be\7G\2\2\u1499\u149a") + buf.write("\7P\2\2\u149a\u14be\7\u0106\2\2\u149b\u14be\7V\2\2\u149c") + buf.write("\u14be\7\u0195\2\2\u149d\u149f\7\u0192\2\2\u149e\u149d") + buf.write("\3\2\2\2\u149e\u149f\3\2\2\2\u149f\u14a0\3\2\2\2\u14a0") + buf.write("\u14be\7\u01af\2\2\u14a1\u14a2\7\u0192\2\2\u14a2\u14a3") + buf.write("\7\66\2\2\u14a3\u14be\7\u0121\2\2\u14a4\u14a6\7q\2\2\u14a5") + buf.write("\u14a7\7\u015c\2\2\u14a6\u14a5\3\2\2\2\u14a6\u14a7\3\2") + buf.write("\2\2\u14a7\u14be\3\2\2\2\u14a8\u14aa\7\u008c\2\2\u14a9") + buf.write("\u14a8\3\2\2\2\u14a9\u14aa\3\2\2\2\u14aa\u14ab\3\2\2\2") + buf.write("\u14ab\u14be\7\u011a\2\2\u14ac\u14ae\7\u00b9\2\2\u14ad") + buf.write("\u14ac\3\2\2\2\u14ad\u14ae\3\2\2\2\u14ae\u14af\3\2\2\2") + buf.write("\u14af\u14be\7~\2\2\u14b0\u14be\7\u00bd\2\2\u14b1\u14be") + buf.write("\7\u00d3\2\2\u14b2\u14be\7\u00db\2\2\u14b3\u14be\7\u00e1") + buf.write("\2\2\u14b4\u14be\7\u00e4\2\2\u14b5\u14be\7\u00f2\2\2\u14b6") + buf.write("\u14be\7\u00f9\2\2\u14b7\u14be\7\u00fe\2\2\u14b8\u14be") + buf.write("\7\u0109\2\2\u14b9\u14ba\7\u0102\2\2\u14ba\u14bb\7\u00de") + buf.write("\2\2\u14bb\u14be\t \2\2\u14bc\u14be\7\u01b6\2\2\u14bd") + buf.write("\u1493\3\2\2\2\u14bd\u1495\3\2\2\2\u14bd\u1496\3\2\2\2") + buf.write("\u14bd\u1497\3\2\2\2\u14bd\u1498\3\2\2\2\u14bd\u1499\3") + buf.write("\2\2\2\u14bd\u149b\3\2\2\2\u14bd\u149c\3\2\2\2\u14bd\u149e") + buf.write("\3\2\2\2\u14bd\u14a1\3\2\2\2\u14bd\u14a4\3\2\2\2\u14bd") + buf.write("\u14a9\3\2\2\2\u14bd\u14ad\3\2\2\2\u14bd\u14b0\3\2\2\2") + buf.write("\u14bd\u14b1\3\2\2\2\u14bd\u14b2\3\2\2\2\u14bd\u14b3\3") + buf.write("\2\2\2\u14bd\u14b4\3\2\2\2\u14bd\u14b5\3\2\2\2\u14bd\u14b6") + buf.write("\3\2\2\2\u14bd\u14b7\3\2\2\2\u14bd\u14b8\3\2\2\2\u14bd") + buf.write("\u14b9\3\2\2\2\u14bd\u14bc\3\2\2\2\u14be\u14bf\3\2\2\2") + buf.write("\u14bf\u14c0\5\u020c\u0107\2\u14c0\u020b\3\2\2\2\u14c1") + buf.write("\u14c3\5\u0198\u00cd\2\u14c2\u14c1\3\2\2\2\u14c2\u14c3") + buf.write("\3\2\2\2\u14c3\u14c4\3\2\2\2\u14c4\u14c6\5\u01da\u00ee") + buf.write("\2\u14c5\u14c7\5\u01f8\u00fd\2\u14c6\u14c5\3\2\2\2\u14c6") + buf.write("\u14c7\3\2\2\2\u14c7\u020d\3\2\2\2\u14c8\u14cc\7\u0265") + buf.write("\2\2\u14c9\u14cc\7\u0266\2\2\u14ca\u14cc\5\u021e\u0110") + buf.write("\2\u14cb\u14c8\3\2\2\2\u14cb\u14c9\3\2\2\2\u14cb\u14ca") + buf.write("\3\2\2\2\u14cc\u020f\3\2\2\2\u14cd\u14d1\5\u020e\u0108") + buf.write("\2\u14ce\u14d1\5\u0216\u010c\2\u14cf\u14d1\5\u0218\u010d") + buf.write("\2\u14d0\u14cd\3\2\2\2\u14d0\u14ce\3\2\2\2\u14d0\u14cf") + buf.write("\3\2\2\2\u14d1\u0211\3\2\2\2\u14d2\u14d6\5\u020e\u0108") + buf.write("\2\u14d3\u14d6\5\u0216\u010c\2\u14d4\u14d6\5\u021a\u010e") + buf.write("\2\u14d5\u14d2\3\2\2\2\u14d5\u14d3\3\2\2\2\u14d5\u14d4") + buf.write("\3\2\2\2\u14d6\u0213\3\2\2\2\u14d7\u14dd\5\u020e\u0108") + buf.write("\2\u14d8\u14dd\5\u021c\u010f\2\u14d9\u14dd\5\u0216\u010c") + buf.write("\2\u14da\u14dd\5\u021a\u010e\2\u14db\u14dd\5\u0218\u010d") + buf.write("\2\u14dc\u14d7\3\2\2\2\u14dc\u14d8\3\2\2\2\u14dc\u14d9") + buf.write("\3\2\2\2\u14dc\u14da\3\2\2\2\u14dc\u14db\3\2\2\2\u14dd") + buf.write("\u0215\3\2\2\2\u14de\u14df\tI\2\2\u14df\u0217\3\2\2\2") + buf.write("\u14e0\u14e1\tJ\2\2\u14e1\u0219\3\2\2\2\u14e2\u14e3\t") + buf.write("K\2\2\u14e3\u021b\3\2\2\2\u14e4\u14e5\tL\2\2\u14e5\u021d") + buf.write("\3\2\2\2\u14e6\u14e7\tM\2\2\u14e7\u021f\3\2\2\2\u14e8") + buf.write("\u14ee\5\u0212\u010a\2\u14e9\u14ea\5\u0210\u0109\2\u14ea") + buf.write("\u14eb\7\u0253\2\2\u14eb\u14ec\5\u0212\u010a\2\u14ec\u14ee") + buf.write("\3\2\2\2\u14ed\u14e8\3\2\2\2\u14ed\u14e9\3\2\2\2\u14ee") + buf.write("\u0221\3\2\2\2\u14ef\u14f4\5\u0224\u0113\2\u14f0\u14f1") + buf.write("\7\u0245\2\2\u14f1\u14f3\5\u0224\u0113\2\u14f2\u14f0\3") + buf.write("\2\2\2\u14f3\u14f6\3\2\2\2\u14f4\u14f2\3\2\2\2\u14f4\u14f5") + buf.write("\3\2\2\2\u14f5\u0223\3\2\2\2\u14f6\u14f4\3\2\2\2\u14f7") + buf.write("\u14f9\7\u0145\2\2\u14f8\u14f7\3\2\2\2\u14f8\u14f9\3\2") + buf.write("\2\2\u14f9\u14fa\3\2\2\2\u14fa\u1504\5\u0228\u0115\2\u14fb") + buf.write("\u14fd\7\u0175\2\2\u14fc\u14fe\5\u0226\u0114\2\u14fd\u14fc") + buf.write("\3\2\2\2\u14fd\u14fe\3\2\2\2\u14fe\u1505\3\2\2\2\u14ff") + buf.write("\u1501\5\u0226\u0114\2\u1500\u14ff\3\2\2\2\u1501\u1502") + buf.write("\3\2\2\2\u1502\u1500\3\2\2\2\u1502\u1503\3\2\2\2\u1503") + buf.write("\u1505\3\2\2\2\u1504\u14fb\3\2\2\2\u1504\u1500\3\2\2\2") + buf.write("\u1504\u1505\3\2\2\2\u1505\u0225\3\2\2\2\u1506\u1508\7") + buf.write("\u0257\2\2\u1507\u1509\7\u0262\2\2\u1508\u1507\3\2\2\2") + buf.write("\u1508\u1509\3\2\2\2\u1509\u150a\3\2\2\2\u150a\u150b\7") + buf.write("\u0258\2\2\u150b\u0227\3\2\2\2\u150c\u1568\7\u0128\2\2") + buf.write("\u150d\u150f\7\u0129\2\2\u150e\u1510\7\u0118\2\2\u150f") + buf.write("\u150e\3\2\2\2\u150f\u1510\3\2\2\2\u1510\u1512\3\2\2\2") + buf.write("\u1511\u1513\5\u022c\u0117\2\u1512\u1511\3\2\2\2\u1512") + buf.write("\u1513\3\2\2\2\u1513\u1568\3\2\2\2\u1514\u1568\7\u012a") + buf.write("\2\2\u1515\u1517\7\u012e\2\2\u1516\u1518\5\u022e\u0118") + buf.write("\2\u1517\u1516\3\2\2\2\u1517\u1518\3\2\2\2\u1518\u1568") + buf.write("\3\2\2\2\u1519\u151b\7\u012f\2\2\u151a\u151c\5\u022e\u0118") + buf.write("\2\u151b\u151a\3\2\2\2\u151b\u151c\3\2\2\2\u151c\u1568") + buf.write("\3\2\2\2\u151d\u151e\7H\2\2\u151e\u1568\7\u0142\2\2\u151f") + buf.write("\u1521\7\u0132\2\2\u1520\u1522\5\u022e\u0118\2\u1521\u1520") + buf.write("\3\2\2\2\u1521\u1522\3\2\2\2\u1522\u1568\3\2\2\2\u1523") + buf.write("\u1568\7\u0136\2\2\u1524\u1568\7\u0137\2\2\u1525\u1527") + buf.write("\7\u0138\2\2\u1526\u1528\5\u022a\u0116\2\u1527\u1526\3") + buf.write("\2\2\2\u1527\u1528\3\2\2\2\u1528\u152a\3\2\2\2\u1529\u152b") + buf.write("\5\u022c\u0117\2\u152a\u1529\3\2\2\2\u152a\u152b\3\2\2") + buf.write("\2\u152b\u1568\3\2\2\2\u152c\u152e\7\u013a\2\2\u152d\u152c") + buf.write("\3\2\2\2\u152d\u152e\3\2\2\2\u152e\u152f\3\2\2\2\u152f") + buf.write("\u1531\tN\2\2\u1530\u1532\7\u0118\2\2\u1531\u1530\3\2") + buf.write("\2\2\u1531\u1532\3\2\2\2\u1532\u1534\3\2\2\2\u1533\u1535") + buf.write("\5\u022c\u0117\2\u1534\u1533\3\2\2\2\u1534\u1535\3\2\2") + buf.write("\2\u1535\u1568\3\2\2\2\u1536\u1538\7\u013b\2\2\u1537\u1539") + buf.write("\7\u0118\2\2\u1538\u1537\3\2\2\2\u1538\u1539\3\2\2\2\u1539") + buf.write("\u153b\3\2\2\2\u153a\u153c\5\u022c\u0117\2\u153b\u153a") + buf.write("\3\2\2\2\u153b\u153c\3\2\2\2\u153c\u1568\3\2\2\2\u153d") + buf.write("\u153f\7\u013e\2\2\u153e\u1540\5\u022e\u0118\2\u153f\u153e") + buf.write("\3\2\2\2\u153f\u1540\3\2\2\2\u1540\u1568\3\2\2\2\u1541") + buf.write("\u1568\7\u0143\2\2\u1542\u1568\7\u0146\2\2\u1543\u1545") + buf.write("\7\u0148\2\2\u1544\u1546\5\u022c\u0117\2\u1545\u1544\3") + buf.write("\2\2\2\u1545\u1546\3\2\2\2\u1546\u154a\3\2\2\2\u1547\u1548") + buf.write("\t\n\2\2\u1548\u1549\7\u0148\2\2\u1549\u154b\7\u0126\2") + buf.write("\2\u154a\u1547\3\2\2\2\u154a\u154b\3\2\2\2\u154b\u1568") + buf.write("\3\2\2\2\u154c\u154e\7\u0149\2\2\u154d\u154f\5\u022c\u0117") + buf.write("\2\u154e\u154d\3\2\2\2\u154e\u154f\3\2\2\2\u154f\u1553") + buf.write("\3\2\2\2\u1550\u1551\t\n\2\2\u1551\u1552\7\u0148\2\2\u1552") + buf.write("\u1554\7\u0126\2\2\u1553\u1550\3\2\2\2\u1553\u1554\3\2") + buf.write("\2\2\u1554\u1568\3\2\2\2\u1555\u1557\7\u014d\2\2\u1556") + buf.write("\u1558\5\u022c\u0117\2\u1557\u1556\3\2\2\2\u1557\u1558") + buf.write("\3\2\2\2\u1558\u1568\3\2\2\2\u1559\u1565\5\u0220\u0111") + buf.write("\2\u155a\u155b\7\u024b\2\2\u155b\u1560\5\u0230\u0119\2") + buf.write("\u155c\u155d\7\u0245\2\2\u155d\u155f\5\u0230\u0119\2\u155e") + buf.write("\u155c\3\2\2\2\u155f\u1562\3\2\2\2\u1560\u155e\3\2\2\2") + buf.write("\u1560\u1561\3\2\2\2\u1561\u1563\3\2\2\2\u1562\u1560\3") + buf.write("\2\2\2\u1563\u1564\7\u024c\2\2\u1564\u1566\3\2\2\2\u1565") + buf.write("\u155a\3\2\2\2\u1565\u1566\3\2\2\2\u1566\u1568\3\2\2\2") + buf.write("\u1567\u150c\3\2\2\2\u1567\u150d\3\2\2\2\u1567\u1514\3") + buf.write("\2\2\2\u1567\u1515\3\2\2\2\u1567\u1519\3\2\2\2\u1567\u151d") + buf.write("\3\2\2\2\u1567\u151f\3\2\2\2\u1567\u1523\3\2\2\2\u1567") + buf.write("\u1524\3\2\2\2\u1567\u1525\3\2\2\2\u1567\u152d\3\2\2\2") + buf.write("\u1567\u1536\3\2\2\2\u1567\u153d\3\2\2\2\u1567\u1541\3") + buf.write("\2\2\2\u1567\u1542\3\2\2\2\u1567\u1543\3\2\2\2\u1567\u154c") + buf.write("\3\2\2\2\u1567\u1555\3\2\2\2\u1567\u1559\3\2\2\2\u1568") + buf.write("\u0229\3\2\2\2\u1569\u1585\7\u0124\2\2\u156a\u1585\7\u0092") + buf.write("\2\2\u156b\u1585\78\2\2\u156c\u1585\7g\2\2\u156d\u1585") + buf.write("\7\u008f\2\2\u156e\u1585\7\u00df\2\2\u156f\u1570\7\u0124") + buf.write("\2\2\u1570\u1571\7\u01b1\2\2\u1571\u1585\7\u0092\2\2\u1572") + buf.write("\u1573\78\2\2\u1573\u1574\7\u01b1\2\2\u1574\u1585\7g\2") + buf.write("\2\u1575\u1576\78\2\2\u1576\u1577\7\u01b1\2\2\u1577\u1585") + buf.write("\7\u008f\2\2\u1578\u1579\78\2\2\u1579\u157a\7\u01b1\2") + buf.write("\2\u157a\u1585\7\u00df\2\2\u157b\u157c\7g\2\2\u157c\u157d") + buf.write("\7\u01b1\2\2\u157d\u1585\7\u008f\2\2\u157e\u157f\7g\2") + buf.write("\2\u157f\u1580\7\u01b1\2\2\u1580\u1585\7\u00df\2\2\u1581") + buf.write("\u1582\7\u008f\2\2\u1582\u1583\7\u01b1\2\2\u1583\u1585") + buf.write("\7\u00df\2\2\u1584\u1569\3\2\2\2\u1584\u156a\3\2\2\2\u1584") + buf.write("\u156b\3\2\2\2\u1584\u156c\3\2\2\2\u1584\u156d\3\2\2\2") + buf.write("\u1584\u156e\3\2\2\2\u1584\u156f\3\2\2\2\u1584\u1572\3") + buf.write("\2\2\2\u1584\u1575\3\2\2\2\u1584\u1578\3\2\2\2\u1584\u157b") + buf.write("\3\2\2\2\u1584\u157e\3\2\2\2\u1584\u1581\3\2\2\2\u1585") + buf.write("\u022b\3\2\2\2\u1586\u1587\7\u024b\2\2\u1587\u1588\7\u0262") + buf.write("\2\2\u1588\u1589\7\u024c\2\2\u1589\u022d\3\2\2\2\u158a") + buf.write("\u158b\7\u024b\2\2\u158b\u158e\7\u0262\2\2\u158c\u158d") + buf.write("\7\u0245\2\2\u158d\u158f\7\u0262\2\2\u158e\u158c\3\2\2") + buf.write("\2\u158e\u158f\3\2\2\2\u158f\u1590\3\2\2\2\u1590\u1591") + buf.write("\7\u024c\2\2\u1591\u022f\3\2\2\2\u1592\u1593\b\u0119\1") + buf.write("\2\u1593\u1594\7\u024b\2\2\u1594\u1595\5\u0230\u0119\2") + buf.write("\u1595\u1597\7\u024c\2\2\u1596\u1598\5\u0200\u0101\2\u1597") + buf.write("\u1596\3\2\2\2\u1597\u1598\3\2\2\2\u1598\u15ac\3\2\2\2") + buf.write("\u1599\u159a\7\u024b\2\2\u159a\u159d\5\u0230\u0119\2\u159b") + buf.write("\u159c\7\u0245\2\2\u159c\u159e\5\u0230\u0119\2\u159d\u159b") + buf.write("\3\2\2\2\u159e\u159f\3\2\2\2\u159f\u159d\3\2\2\2\u159f") + buf.write("\u15a0\3\2\2\2\u15a0\u15a1\3\2\2\2\u15a1\u15a2\7\u024c") + buf.write("\2\2\u15a2\u15ac\3\2\2\2\u15a3\u15a4\t8\2\2\u15a4\u15ac") + buf.write("\5\u0230\u0119\32\u15a5\u15a6\5\u0234\u011b\2\u15a6\u15a7") + buf.write("\5\u0230\u0119\24\u15a7\u15ac\3\2\2\2\u15a8\u15a9\7\u01a0") + buf.write("\2\2\u15a9\u15ac\5\u0230\u0119\6\u15aa\u15ac\5\u023a\u011e") + buf.write("\2\u15ab\u1592\3\2\2\2\u15ab\u1599\3\2\2\2\u15ab\u15a3") + buf.write("\3\2\2\2\u15ab\u15a5\3\2\2\2\u15ab\u15a8\3\2\2\2\u15ab") + buf.write("\u15aa\3\2\2\2\u15ac\u1634\3\2\2\2\u15ad\u15ae\f\31\2") + buf.write("\2\u15ae\u15af\7\20\2\2\u15af\u15b0\7\u0148\2\2\u15b0") + buf.write("\u15b1\7\u0126\2\2\u15b1\u1633\5\u0230\u0119\32\u15b2") + buf.write("\u15b3\f\30\2\2\u15b3\u15b4\7\u0252\2\2\u15b4\u1633\5") + buf.write("\u0230\u0119\31\u15b5\u15b6\f\27\2\2\u15b6\u15b7\tO\2") + buf.write("\2\u15b7\u1633\5\u0230\u0119\30\u15b8\u15b9\f\26\2\2\u15b9") + buf.write("\u15ba\t8\2\2\u15ba\u1633\5\u0230\u0119\27\u15bb\u15bc") + buf.write("\f\25\2\2\u15bc\u15bd\5\u0234\u011b\2\u15bd\u15be\5\u0230") + buf.write("\u0119\26\u15be\u1633\3\2\2\2\u15bf\u15c1\f\21\2\2\u15c0") + buf.write("\u15c2\7\u01a0\2\2\u15c1\u15c0\3\2\2\2\u15c1\u15c2\3\2") + buf.write("\2\2\u15c2\u15c3\3\2\2\2\u15c3\u15c5\7\u0127\2\2\u15c4") + buf.write("\u15c6\tP\2\2\u15c5\u15c4\3\2\2\2\u15c5\u15c6\3\2\2\2") + buf.write("\u15c6\u15c7\3\2\2\2\u15c7\u15c8\5\u0232\u011a\2\u15c8") + buf.write("\u15c9\7\u0173\2\2\u15c9\u15ca\5\u0230\u0119\22\u15ca") + buf.write("\u1633\3\2\2\2\u15cb\u15cd\f\20\2\2\u15cc\u15ce\7\u01a0") + buf.write("\2\2\u15cd\u15cc\3\2\2\2\u15cd\u15ce\3\2\2\2\u15ce\u15d3") + buf.write("\3\2\2\2\u15cf\u15d4\7\u0167\2\2\u15d0\u15d4\7\u0161\2") + buf.write("\2\u15d1\u15d2\7\u016d\2\2\u15d2\u15d4\7\u01b1\2\2\u15d3") + buf.write("\u15cf\3\2\2\2\u15d3\u15d0\3\2\2\2\u15d3\u15d1\3\2\2\2") + buf.write("\u15d4\u15d5\3\2\2\2\u15d5\u1633\5\u0230\u0119\21\u15d6") + buf.write("\u15d8\f\17\2\2\u15d7\u15d9\7\u01a0\2\2\u15d8\u15d7\3") + buf.write("\2\2\2\u15d8\u15d9\3\2\2\2\u15d9\u15de\3\2\2\2\u15da\u15df") + buf.write("\7\u0167\2\2\u15db\u15df\7\u0161\2\2\u15dc\u15dd\7\u016d") + buf.write("\2\2\u15dd\u15df\7\u01b1\2\2\u15de\u15da\3\2\2\2\u15de") + buf.write("\u15db\3\2\2\2\u15de\u15dc\3\2\2\2\u15df\u15e0\3\2\2\2") + buf.write("\u15e0\u15e1\5\u0230\u0119\2\u15e1\u15e2\7O\2\2\u15e2") + buf.write("\u15e3\5\u0230\u0119\20\u15e3\u1633\3\2\2\2\u15e4\u15e5") + buf.write("\f\16\2\2\u15e5\u15e6\tQ\2\2\u15e6\u1633\5\u0230\u0119") + buf.write("\17\u15e7\u15e8\f\f\2\2\u15e8\u15ea\7\u0163\2\2\u15e9") + buf.write("\u15eb\7\u01a0\2\2\u15ea\u15e9\3\2\2\2\u15ea\u15eb\3\2") + buf.write("\2\2\u15eb\u15ec\3\2\2\2\u15ec\u15ed\7\u018a\2\2\u15ed") + buf.write("\u15ee\7\u0193\2\2\u15ee\u1633\5\u0230\u0119\r\u15ef\u15f0") + buf.write("\f\5\2\2\u15f0\u15f1\7\u0173\2\2\u15f1\u1633\5\u0230\u0119") + buf.write("\6\u15f2\u15f3\f\4\2\2\u15f3\u15f4\7\u01a5\2\2\u15f4\u1633") + buf.write("\5\u0230\u0119\5\u15f5\u15f6\f\36\2\2\u15f6\u15f7\7\u0241") + buf.write("\2\2\u15f7\u1633\5\u0224\u0113\2\u15f8\u15f9\f\33\2\2") + buf.write("\u15f9\u1633\5\u01fa\u00fe\2\u15fa\u15fb\f\23\2\2\u15fb") + buf.write("\u1633\5\u0234\u011b\2\u15fc\u15fe\f\22\2\2\u15fd\u15ff") + buf.write("\7\u01a0\2\2\u15fe\u15fd\3\2\2\2\u15fe\u15ff\3\2\2\2\u15ff") + buf.write("\u1600\3\2\2\2\u1600\u1601\7\u0197\2\2\u1601\u160b\7\u024b") + buf.write("\2\2\u1602\u160c\5\u0274\u013b\2\u1603\u1608\5\u0230\u0119") + buf.write("\2\u1604\u1605\7\u0245\2\2\u1605\u1607\5\u0230\u0119\2") + buf.write("\u1606\u1604\3\2\2\2\u1607\u160a\3\2\2\2\u1608\u1606\3") + buf.write("\2\2\2\u1608\u1609\3\2\2\2\u1609\u160c\3\2\2\2\u160a\u1608") + buf.write("\3\2\2\2\u160b\u1602\3\2\2\2\u160b\u1603\3\2\2\2\u160c") + buf.write("\u160d\3\2\2\2\u160d\u160e\7\u024c\2\2\u160e\u1633\3\2") + buf.write("\2\2\u160f\u1610\f\r\2\2\u1610\u1612\7\u0163\2\2\u1611") + buf.write("\u1613\7\u01a0\2\2\u1612\u1611\3\2\2\2\u1612\u1613\3\2") + buf.write("\2\2\u1613\u1616\3\2\2\2\u1614\u1617\5\u0240\u0121\2\u1615") + buf.write("\u1617\7\u01a1\2\2\u1616\u1614\3\2\2\2\u1616\u1615\3\2") + buf.write("\2\2\u1617\u1633\3\2\2\2\u1618\u1619\f\13\2\2\u1619\u161b") + buf.write("\7\u0163\2\2\u161a\u161c\7\u01a0\2\2\u161b\u161a\3\2\2") + buf.write("\2\u161b\u161c\3\2\2\2\u161c\u161d\3\2\2\2\u161d\u1633") + buf.write("\7F\2\2\u161e\u161f\f\n\2\2\u161f\u1621\7\u0163\2\2\u1620") + buf.write("\u1622\7\u01a0\2\2\u1621\u1620\3\2\2\2\u1621\u1622\3\2") + buf.write("\2\2\u1622\u1623\3\2\2\2\u1623\u1633\7\u010e\2\2\u1624") + buf.write("\u1625\f\t\2\2\u1625\u1627\7\u0163\2\2\u1626\u1628\7\u01a0") + buf.write("\2\2\u1627\u1626\3\2\2\2\u1627\u1628\3\2\2\2\u1628\u1629") + buf.write("\3\2\2\2\u1629\u162a\7\u009e\2\2\u162a\u162b\7\u024b\2") + buf.write("\2\u162b\u162c\5\u0222\u0112\2\u162c\u162d\7\u024c\2\2") + buf.write("\u162d\u1633\3\2\2\2\u162e\u162f\f\b\2\2\u162f\u1633\7") + buf.write("\u0164\2\2\u1630\u1631\f\7\2\2\u1631\u1633\7\u0169\2\2") + buf.write("\u1632\u15ad\3\2\2\2\u1632\u15b2\3\2\2\2\u1632\u15b5\3") + buf.write("\2\2\2\u1632\u15b8\3\2\2\2\u1632\u15bb\3\2\2\2\u1632\u15bf") + buf.write("\3\2\2\2\u1632\u15cb\3\2\2\2\u1632\u15d6\3\2\2\2\u1632") + buf.write("\u15e4\3\2\2\2\u1632\u15e7\3\2\2\2\u1632\u15ef\3\2\2\2") + buf.write("\u1632\u15f2\3\2\2\2\u1632\u15f5\3\2\2\2\u1632\u15f8\3") + buf.write("\2\2\2\u1632\u15fa\3\2\2\2\u1632\u15fc\3\2\2\2\u1632\u160f") + buf.write("\3\2\2\2\u1632\u1618\3\2\2\2\u1632\u161e\3\2\2\2\u1632") + buf.write("\u1624\3\2\2\2\u1632\u162e\3\2\2\2\u1632\u1630\3\2\2\2") + buf.write("\u1633\u1636\3\2\2\2\u1634\u1632\3\2\2\2\u1634\u1635\3") + buf.write("\2\2\2\u1635\u0231\3\2\2\2\u1636\u1634\3\2\2\2\u1637\u1638") + buf.write("\b\u011a\1\2\u1638\u1639\7\u024b\2\2\u1639\u163a\5\u0230") + buf.write("\u0119\2\u163a\u163c\7\u024c\2\2\u163b\u163d\5\u0200\u0101") + buf.write("\2\u163c\u163b\3\2\2\2\u163c\u163d\3\2\2\2\u163d\u164f") + buf.write("\3\2\2\2\u163e\u163f\7\u024b\2\2\u163f\u1642\5\u0230\u0119") + buf.write("\2\u1640\u1641\7\u0245\2\2\u1641\u1643\5\u0230\u0119\2") + buf.write("\u1642\u1640\3\2\2\2\u1643\u1644\3\2\2\2\u1644\u1642\3") + buf.write("\2\2\2\u1644\u1645\3\2\2\2\u1645\u1646\3\2\2\2\u1646\u1647") + buf.write("\7\u024c\2\2\u1647\u164f\3\2\2\2\u1648\u1649\t8\2\2\u1649") + buf.write("\u164f\5\u0232\u011a\17\u164a\u164b\5\u0234\u011b\2\u164b") + buf.write("\u164c\5\u0232\u011a\n\u164c\u164f\3\2\2\2\u164d\u164f") + buf.write("\5\u023a\u011e\2\u164e\u1637\3\2\2\2\u164e\u163e\3\2\2") + buf.write("\2\u164e\u1648\3\2\2\2\u164e\u164a\3\2\2\2\u164e\u164d") + buf.write("\3\2\2\2\u164f\u1685\3\2\2\2\u1650\u1651\f\16\2\2\u1651") + buf.write("\u1652\7\u0252\2\2\u1652\u1684\5\u0232\u011a\17\u1653") + buf.write("\u1654\f\r\2\2\u1654\u1655\tO\2\2\u1655\u1684\5\u0232") + buf.write("\u011a\16\u1656\u1657\f\f\2\2\u1657\u1658\t8\2\2\u1658") + buf.write("\u1684\5\u0232\u011a\r\u1659\u165a\f\13\2\2\u165a\u165b") + buf.write("\5\u0234\u011b\2\u165b\u165c\5\u0232\u011a\f\u165c\u1684") + buf.write("\3\2\2\2\u165d\u165e\f\b\2\2\u165e\u165f\tQ\2\2\u165f") + buf.write("\u1684\5\u0232\u011a\t\u1660\u1661\f\7\2\2\u1661\u1663") + buf.write("\7\u0163\2\2\u1662\u1664\7\u01a0\2\2\u1663\u1662\3\2\2") + buf.write("\2\u1663\u1664\3\2\2\2\u1664\u1665\3\2\2\2\u1665\u1666") + buf.write("\7\u018a\2\2\u1666\u1667\7\u0193\2\2\u1667\u1684\5\u0232") + buf.write("\u011a\b\u1668\u1669\f\22\2\2\u1669\u166a\7\u0241\2\2") + buf.write("\u166a\u1684\5\u0224\u0113\2\u166b\u166c\f\t\2\2\u166c") + buf.write("\u1684\5\u0234\u011b\2\u166d\u166e\f\6\2\2\u166e\u1670") + buf.write("\7\u0163\2\2\u166f\u1671\7\u01a0\2\2\u1670\u166f\3\2\2") + buf.write("\2\u1670\u1671\3\2\2\2\u1671\u1672\3\2\2\2\u1672\u1684") + buf.write("\7F\2\2\u1673\u1674\f\5\2\2\u1674\u1676\7\u0163\2\2\u1675") + buf.write("\u1677\7\u01a0\2\2\u1676\u1675\3\2\2\2\u1676\u1677\3\2") + buf.write("\2\2\u1677\u1678\3\2\2\2\u1678\u1684\7\u010e\2\2\u1679") + buf.write("\u167a\f\4\2\2\u167a\u167c\7\u0163\2\2\u167b\u167d\7\u01a0") + buf.write("\2\2\u167c\u167b\3\2\2\2\u167c\u167d\3\2\2\2\u167d\u167e") + buf.write("\3\2\2\2\u167e\u167f\7\u009e\2\2\u167f\u1680\7\u024b\2") + buf.write("\2\u1680\u1681\5\u0222\u0112\2\u1681\u1682\7\u024c\2\2") + buf.write("\u1682\u1684\3\2\2\2\u1683\u1650\3\2\2\2\u1683\u1653\3") + buf.write("\2\2\2\u1683\u1656\3\2\2\2\u1683\u1659\3\2\2\2\u1683\u165d") + buf.write("\3\2\2\2\u1683\u1660\3\2\2\2\u1683\u1668\3\2\2\2\u1683") + buf.write("\u166b\3\2\2\2\u1683\u166d\3\2\2\2\u1683\u1673\3\2\2\2") + buf.write("\u1683\u1679\3\2\2\2\u1684\u1687\3\2\2\2\u1685\u1683\3") + buf.write("\2\2\2\u1685\u1686\3\2\2\2\u1686\u0233\3\2\2\2\u1687\u1685") + buf.write("\3\2\2\2\u1688\u1691\5\u01d4\u00eb\2\u1689\u168a\7\u00a2") + buf.write("\2\2\u168a\u168b\7\u024b\2\2\u168b\u168c\5\u0210\u0109") + buf.write("\2\u168c\u168d\7\u0253\2\2\u168d\u168e\5\u01d2\u00ea\2") + buf.write("\u168e\u168f\7\u024c\2\2\u168f\u1691\3\2\2\2\u1690\u1688") + buf.write("\3\2\2\2\u1690\u1689\3\2\2\2\u1691\u0235\3\2\2\2\u1692") + buf.write("\u169b\5\u01d2\u00ea\2\u1693\u1694\7\u00a2\2\2\u1694\u1695") + buf.write("\7\u024b\2\2\u1695\u1696\5\u0210\u0109\2\u1696\u1697\7") + buf.write("\u0253\2\2\u1697\u1698\5\u01d2\u00ea\2\u1698\u1699\7\u024c") + buf.write("\2\2\u1699\u169b\3\2\2\2\u169a\u1692\3\2\2\2\u169a\u1693") + buf.write("\3\2\2\2\u169b\u0237\3\2\2\2\u169c\u169d\7\u024b\2\2\u169d") + buf.write("\u169e\5\u0230\u0119\2\u169e\u169f\7\u0245\2\2\u169f\u16a0") + buf.write("\5\u0230\u0119\2\u16a0\u16a1\7\u024c\2\2\u16a1\u16a2\7") + buf.write("\u016b\2\2\u16a2\u16a3\7\u024b\2\2\u16a3\u16a4\5\u0230") + buf.write("\u0119\2\u16a4\u16a5\7\u0245\2\2\u16a5\u16a6\5\u0230\u0119") + buf.write("\2\u16a6\u16a7\7\u024c\2\2\u16a7\u0239\3\2\2\2\u16a8\u16bb") + buf.write("\5\u023c\u011f\2\u16a9\u16aa\7\u024b\2\2\u16aa\u16ab\5") + buf.write("\u0274\u013b\2\u16ab\u16ad\7\u024c\2\2\u16ac\u16ae\5\u0200") + buf.write("\u0101\2\u16ad\u16ac\3\2\2\2\u16ad\u16ae\3\2\2\2\u16ae") + buf.write("\u16bb\3\2\2\2\u16af\u16bb\5\u0242\u0122\2\u16b0\u16bb") + buf.write("\7\u01a1\2\2\u16b1\u16bb\7\u024f\2\2\u16b2\u16bb\5\u025a") + buf.write("\u012e\2\u16b3\u16b4\7\u0130\2\2\u16b4\u16bb\5\u026e\u0138") + buf.write("\2\u16b5\u16bb\5\u0246\u0124\2\u16b6\u16bb\5\u01fc\u00ff") + buf.write("\2\u16b7\u16bb\5\u0264\u0133\2\u16b8\u16bb\5\u0268\u0135") + buf.write("\2\u16b9\u16bb\5\u0238\u011d\2\u16ba\u16a8\3\2\2\2\u16ba") + buf.write("\u16a9\3\2\2\2\u16ba\u16af\3\2\2\2\u16ba\u16b0\3\2\2\2") + buf.write("\u16ba\u16b1\3\2\2\2\u16ba\u16b2\3\2\2\2\u16ba\u16b3\3") + buf.write("\2\2\2\u16ba\u16b5\3\2\2\2\u16ba\u16b6\3\2\2\2\u16ba\u16b7") + buf.write("\3\2\2\2\u16ba\u16b8\3\2\2\2\u16ba\u16b9\3\2\2\2\u16bb") + buf.write("\u023b\3\2\2\2\u16bc\u16c0\5\u023e\u0120\2\u16bd\u16c0") + buf.write("\5\u0146\u00a4\2\u16be\u16c0\5\u0240\u0121\2\u16bf\u16bc") + buf.write("\3\2\2\2\u16bf\u16bd\3\2\2\2\u16bf\u16be\3\2\2\2\u16c0") + buf.write("\u023d\3\2\2\2\u16c1\u16c2\tR\2\2\u16c2\u023f\3\2\2\2") + buf.write("\u16c3\u16c4\tS\2\2\u16c4\u0241\3\2\2\2\u16c5\u16c7\7") + buf.write("\u017a\2\2\u16c6\u16c8\5\u0230\u0119\2\u16c7\u16c6\3\2") + buf.write("\2\2\u16c7\u16c8\3\2\2\2\u16c8\u16ce\3\2\2\2\u16c9\u16ca") + buf.write("\7\u01b9\2\2\u16ca\u16cb\5\u0230\u0119\2\u16cb\u16cc\7") + buf.write("\u01b0\2\2\u16cc\u16cd\5\u0230\u0119\2\u16cd\u16cf\3\2") + buf.write("\2\2\u16ce\u16c9\3\2\2\2\u16cf\u16d0\3\2\2\2\u16d0\u16ce") + buf.write("\3\2\2\2\u16d0\u16d1\3\2\2\2\u16d1\u16d4\3\2\2\2\u16d2") + buf.write("\u16d3\7\u018c\2\2\u16d3\u16d5\5\u0230\u0119\2\u16d4\u16d2") + buf.write("\3\2\2\2\u16d4\u16d5\3\2\2\2\u16d5\u16d6\3\2\2\2\u16d6") + buf.write("\u16d7\7\u018d\2\2\u16d7\u0243\3\2\2\2\u16d8\u16d9\tT") + buf.write("\2\2\u16d9\u16da\7\u024b\2\2\u16da\u16db\5\u0230\u0119") + buf.write("\2\u16db\u16dc\7\u0176\2\2\u16dc\u16dd\5\u0224\u0113\2") + buf.write("\u16dd\u16de\7\u024c\2\2\u16de\u0245\3\2\2\2\u16df\u16e0") + buf.write("\5\u0220\u0111\2\u16e0\u16ef\7\u024b\2\2\u16e1\u16e3\5") + buf.write("\u026c\u0137\2\u16e2\u16e1\3\2\2\2\u16e2\u16e3\3\2\2\2") + buf.write("\u16e3\u16e4\3\2\2\2\u16e4\u16e9\5\u0248\u0125\2\u16e5") + buf.write("\u16e6\7\u0245\2\2\u16e6\u16e8\5\u0248\u0125\2\u16e7\u16e5") + buf.write("\3\2\2\2\u16e8\u16eb\3\2\2\2\u16e9\u16e7\3\2\2\2\u16e9") + buf.write("\u16ea\3\2\2\2\u16ea\u16ed\3\2\2\2\u16eb\u16e9\3\2\2\2") + buf.write("\u16ec\u16ee\5\u0298\u014d\2\u16ed\u16ec\3\2\2\2\u16ed") + buf.write("\u16ee\3\2\2\2\u16ee\u16f0\3\2\2\2\u16ef\u16e2\3\2\2\2") + buf.write("\u16ef\u16f0\3\2\2\2\u16f0\u16f1\3\2\2\2\u16f1\u16f8\7") + buf.write("\u024c\2\2\u16f2\u16f3\7\u011e\2\2\u16f3\u16f4\7\u0195") + buf.write("\2\2\u16f4\u16f5\7\u024b\2\2\u16f5\u16f6\5\u0298\u014d") + buf.write("\2\u16f6\u16f7\7\u024c\2\2\u16f7\u16f9\3\2\2\2\u16f8\u16f2") + buf.write("\3\2\2\2\u16f8\u16f9\3\2\2\2\u16f9\u16fb\3\2\2\2\u16fa") + buf.write("\u16fc\5\u025c\u012f\2\u16fb\u16fa\3\2\2\2\u16fb\u16fc") + buf.write("\3\2\2\2\u16fc\u1702\3\2\2\2\u16fd\u1700\7\u00a7\2\2\u16fe") + buf.write("\u1701\5\u0210\u0109\2\u16ff\u1701\5\u025e\u0130\2\u1700") + buf.write("\u16fe\3\2\2\2\u1700\u16ff\3\2\2\2\u1701\u1703\3\2\2\2") + buf.write("\u1702\u16fd\3\2\2\2\u1702\u1703\3\2\2\2\u1703\u170b\3") + buf.write("\2\2\2\u1704\u170b\5\u024c\u0127\2\u1705\u170b\5\u024e") + buf.write("\u0128\2\u1706\u170b\5\u0250\u0129\2\u1707\u170b\5\u0252") + buf.write("\u012a\2\u1708\u170b\5\u0254\u012b\2\u1709\u170b\5\u0256") + buf.write("\u012c\2\u170a\u16df\3\2\2\2\u170a\u1704\3\2\2\2\u170a") + buf.write("\u1705\3\2\2\2\u170a\u1706\3\2\2\2\u170a\u1707\3\2\2\2") + buf.write("\u170a\u1708\3\2\2\2\u170a\u1709\3\2\2\2\u170b\u0247\3") + buf.write("\2\2\2\u170c\u170e\7\u01b8\2\2\u170d\u170c\3\2\2\2\u170d") + buf.write("\u170e\3\2\2\2\u170e\u1712\3\2\2\2\u170f\u1710\5\u0210") + buf.write("\u0109\2\u1710\u1711\5\u024a\u0126\2\u1711\u1713\3\2\2") + buf.write("\2\u1712\u170f\3\2\2\2\u1712\u1713\3\2\2\2\u1713\u1714") + buf.write("\3\2\2\2\u1714\u1715\5\u0230\u0119\2\u1715\u0249\3\2\2") + buf.write("\2\u1716\u1717\tU\2\2\u1717\u024b\3\2\2\2\u1718\u1719") + buf.write("\tV\2\2\u1719\u171a\7\u024b\2\2\u171a\u171f\5\u0230\u0119") + buf.write("\2\u171b\u171c\7\u0245\2\2\u171c\u171e\5\u0230\u0119\2") + buf.write("\u171d\u171b\3\2\2\2\u171e\u1721\3\2\2\2\u171f\u171d\3") + buf.write("\2\2\2\u171f\u1720\3\2\2\2\u1720\u1722\3\2\2\2\u1721\u171f") + buf.write("\3\2\2\2\u1722\u1723\7\u024c\2\2\u1723\u1732\3\2\2\2\u1724") + buf.write("\u1725\7\u0144\2\2\u1725\u172e\7\u024b\2\2\u1726\u172b") + buf.write("\5\u0230\u0119\2\u1727\u1728\7\u0245\2\2\u1728\u172a\5") + buf.write("\u0230\u0119\2\u1729\u1727\3\2\2\2\u172a\u172d\3\2\2\2") + buf.write("\u172b\u1729\3\2\2\2\u172b\u172c\3\2\2\2\u172c\u172f\3") + buf.write("\2\2\2\u172d\u172b\3\2\2\2\u172e\u1726\3\2\2\2\u172e\u172f") + buf.write("\3\2\2\2\u172f\u1730\3\2\2\2\u1730\u1732\7\u024c\2\2\u1731") + buf.write("\u1718\3\2\2\2\u1731\u1724\3\2\2\2\u1732\u024d\3\2\2\2") + buf.write("\u1733\u1734\7\u0131\2\2\u1734\u1737\7\u024b\2\2\u1735") + buf.write("\u1738\5\u0210\u0109\2\u1736\u1738\5\u0146\u00a4\2\u1737") + buf.write("\u1735\3\2\2\2\u1737\u1736\3\2\2\2\u1738\u1739\3\2\2\2") + buf.write("\u1739\u173a\7\u0193\2\2\u173a\u173b\5\u0230\u0119\2\u173b") + buf.write("\u173c\7\u024c\2\2\u173c\u024f\3\2\2\2\u173d\u1744\7\u0181") + buf.write("\2\2\u173e\u1744\7\u015e\2\2\u173f\u1744\7\u0186\2\2\u1740") + buf.write("\u1744\7\u01ac\2\2\u1741\u1744\7\u01b6\2\2\u1742\u1744") + buf.write("\5\u0244\u0123\2\u1743\u173d\3\2\2\2\u1743\u173e\3\2\2") + buf.write("\2\u1743\u173f\3\2\2\2\u1743\u1740\3\2\2\2\u1743\u1741") + buf.write("\3\2\2\2\u1743\u1742\3\2\2\2\u1744\u0251\3\2\2\2\u1745") + buf.write("\u1757\7\u0182\2\2\u1746\u1748\7\u0184\2\2\u1747\u1749") + buf.write("\5\u022c\u0117\2\u1748\u1747\3\2\2\2\u1748\u1749\3\2\2") + buf.write("\2\u1749\u1757\3\2\2\2\u174a\u174c\7\u0185\2\2\u174b\u174d") + buf.write("\5\u022c\u0117\2\u174c\u174b\3\2\2\2\u174c\u174d\3\2\2") + buf.write("\2\u174d\u1757\3\2\2\2\u174e\u1750\7\u019e\2\2\u174f\u1751") + buf.write("\5\u022c\u0117\2\u1750\u174f\3\2\2\2\u1750\u1751\3\2\2") + buf.write("\2\u1751\u1757\3\2\2\2\u1752\u1754\7\u019f\2\2\u1753\u1755") + buf.write("\5\u022c\u0117\2\u1754\u1753\3\2\2\2\u1754\u1755\3\2\2") + buf.write("\2\u1755\u1757\3\2\2\2\u1756\u1745\3\2\2\2\u1756\u1746") + buf.write("\3\2\2\2\u1756\u174a\3\2\2\2\u1756\u174e\3\2\2\2\u1756") + buf.write("\u1752\3\2\2\2\u1757\u0253\3\2\2\2\u1758\u1759\7\u014b") + buf.write("\2\2\u1759\u175b\7\u024b\2\2\u175a\u175c\tW\2\2\u175b") + buf.write("\u175a\3\2\2\2\u175b\u175c\3\2\2\2\u175c\u1769\3\2\2\2") + buf.write("\u175d\u175e\5\u0230\u0119\2\u175e\u175f\7\u0193\2\2\u175f") + buf.write("\u1760\5\u0230\u0119\2\u1760\u176a\3\2\2\2\u1761\u1763") + buf.write("\7\u0193\2\2\u1762\u1761\3\2\2\2\u1762\u1763\3\2\2\2\u1763") + buf.write("\u1764\3\2\2\2\u1764\u1767\5\u0230\u0119\2\u1765\u1766") + buf.write("\7\u0245\2\2\u1766\u1768\5\u0230\u0119\2\u1767\u1765\3") + buf.write("\2\2\2\u1767\u1768\3\2\2\2\u1768\u176a\3\2\2\2\u1769\u175d") + buf.write("\3\2\2\2\u1769\u1762\3\2\2\2\u176a\u176b\3\2\2\2\u176b") + buf.write("\u176c\7\u024c\2\2\u176c\u179c\3\2\2\2\u176d\u176e\7\u0147") + buf.write("\2\2\u176e\u176f\7\u024b\2\2\u176f\u1774\5\u0230\u0119") + buf.write("\2\u1770\u1771\7\u0245\2\2\u1771\u1773\5\u0230\u0119\2") + buf.write("\u1772\u1770\3\2\2\2\u1773\u1776\3\2\2\2\u1774\u1772\3") + buf.write("\2\2\2\u1774\u1775\3\2\2\2\u1775\u1779\3\2\2\2\u1776\u1774") + buf.write("\3\2\2\2\u1777\u1778\7\u0193\2\2\u1778\u177a\5\u0230\u0119") + buf.write("\2\u1779\u1777\3\2\2\2\u1779\u177a\3\2\2\2\u177a\u177d") + buf.write("\3\2\2\2\u177b\u177c\7\u0191\2\2\u177c\u177e\5\u0230\u0119") + buf.write("\2\u177d\u177b\3\2\2\2\u177d\u177e\3\2\2\2\u177e\u177f") + buf.write("\3\2\2\2\u177f\u1780\7\u024c\2\2\u1780\u179c\3\2\2\2\u1781") + buf.write("\u1782\7\u0141\2\2\u1782\u1783\7\u024b\2\2\u1783\u1784") + buf.write("\5\u0232\u011a\2\u1784\u1785\7\u0197\2\2\u1785\u1786\5") + buf.write("\u0230\u0119\2\u1786\u1787\7\u024c\2\2\u1787\u179c\3\2") + buf.write("\2\2\u1788\u1789\7\u0140\2\2\u1789\u178a\7\u024b\2\2\u178a") + buf.write("\u178b\5\u0230\u0119\2\u178b\u178c\7\u01a7\2\2\u178c\u178d") + buf.write("\5\u0230\u0119\2\u178d\u178e\7\u0193\2\2\u178e\u1791\5") + buf.write("\u0230\u0119\2\u178f\u1790\7\u0191\2\2\u1790\u1792\5\u0230") + buf.write("\u0119\2\u1791\u178f\3\2\2\2\u1791\u1792\3\2\2\2\u1792") + buf.write("\u1793\3\2\2\2\u1793\u1794\7\u024c\2\2\u1794\u179c\3\2") + buf.write("\2\2\u1795\u1796\7\u015b\2\2\u1796\u1797\7\u0191\2\2\u1797") + buf.write("\u1798\7\u024b\2\2\u1798\u1799\5\u0230\u0119\2\u1799\u179a") + buf.write("\7\u024c\2\2\u179a\u179c\3\2\2\2\u179b\u1758\3\2\2\2\u179b") + buf.write("\u176d\3\2\2\2\u179b\u1781\3\2\2\2\u179b\u1788\3\2\2\2") + buf.write("\u179b\u1795\3\2\2\2\u179c\u0255\3\2\2\2\u179d\u179e\7") + buf.write("\u0150\2\2\u179e\u179f\7\u024b\2\2\u179f\u17a0\7\u0094") + buf.write("\2\2\u17a0\u17b6\5\u0210\u0109\2\u17a1\u17a2\7\u0245\2") + buf.write("\2\u17a2\u17a3\7\u014e\2\2\u17a3\u17a4\7\u024b\2\2\u17a4") + buf.write("\u17a7\5\u0230\u0119\2\u17a5\u17a6\7\u0176\2\2\u17a6\u17a8") + buf.write("\5\u0210\u0109\2\u17a7\u17a5\3\2\2\2\u17a7\u17a8\3\2\2") + buf.write("\2\u17a8\u17b1\3\2\2\2\u17a9\u17aa\7\u0245\2\2\u17aa\u17ad") + buf.write("\5\u0230\u0119\2\u17ab\u17ac\7\u0176\2\2\u17ac\u17ae\5") + buf.write("\u0210\u0109\2\u17ad\u17ab\3\2\2\2\u17ad\u17ae\3\2\2\2") + buf.write("\u17ae\u17b0\3\2\2\2\u17af\u17a9\3\2\2\2\u17b0\u17b3\3") + buf.write("\2\2\2\u17b1\u17af\3\2\2\2\u17b1\u17b2\3\2\2\2\u17b2\u17b4") + buf.write("\3\2\2\2\u17b3\u17b1\3\2\2\2\u17b4\u17b5\7\u024c\2\2\u17b5") + buf.write("\u17b7\3\2\2\2\u17b6\u17a1\3\2\2\2\u17b6\u17b7\3\2\2\2") + buf.write("\u17b7\u17bc\3\2\2\2\u17b8\u17b9\7\u0245\2\2\u17b9\u17bb") + buf.write("\5\u0230\u0119\2\u17ba\u17b8\3\2\2\2\u17bb\u17be\3\2\2") + buf.write("\2\u17bc\u17ba\3\2\2\2\u17bc\u17bd\3\2\2\2\u17bd\u17bf") + buf.write("\3\2\2\2\u17be\u17bc\3\2\2\2\u17bf\u17c0\7\u024c\2\2\u17c0") + buf.write("\u183f\3\2\2\2\u17c1\u17c2\7\u0152\2\2\u17c2\u17c3\7\u024b") + buf.write("\2\2\u17c3\u17c6\5\u0230\u0119\2\u17c4\u17c5\7\u0176\2") + buf.write("\2\u17c5\u17c7\5\u0210\u0109\2\u17c6\u17c4\3\2\2\2\u17c6") + buf.write("\u17c7\3\2\2\2\u17c7\u17d0\3\2\2\2\u17c8\u17c9\7\u0245") + buf.write("\2\2\u17c9\u17cc\5\u0230\u0119\2\u17ca\u17cb\7\u0176\2") + buf.write("\2\u17cb\u17cd\5\u0210\u0109\2\u17cc\u17ca\3\2\2\2\u17cc") + buf.write("\u17cd\3\2\2\2\u17cd\u17cf\3\2\2\2\u17ce\u17c8\3\2\2\2") + buf.write("\u17cf\u17d2\3\2\2\2\u17d0\u17ce\3\2\2\2\u17d0\u17d1\3") + buf.write("\2\2\2\u17d1\u17d3\3\2\2\2\u17d2\u17d0\3\2\2\2\u17d3\u17d4") + buf.write("\7\u024c\2\2\u17d4\u183f\3\2\2\2\u17d5\u17d6\7\u0155\2") + buf.write("\2\u17d6\u17d7\7\u024b\2\2\u17d7\u17d8\7\u0094\2\2\u17d8") + buf.write("\u17db\5\u0210\u0109\2\u17d9\u17da\7\u0245\2\2\u17da\u17dc") + buf.write("\5\u0230\u0119\2\u17db\u17d9\3\2\2\2\u17db\u17dc\3\2\2") + buf.write("\2\u17dc\u17dd\3\2\2\2\u17dd\u17de\7\u024c\2\2\u17de\u183f") + buf.write("\3\2\2\2\u17df\u17e0\7\u0156\2\2\u17e0\u17e1\7\u024b\2") + buf.write("\2\u17e1\u17e2\5\u0230\u0119\2\u17e2\u17e3\7\u0245\2\2") + buf.write("\u17e3\u17e7\7\u0119\2\2\u17e4\u17e8\5\u0230\u0119\2\u17e5") + buf.write("\u17e6\7\u0098\2\2\u17e6\u17e8\7\u0117\2\2\u17e7\u17e4") + buf.write("\3\2\2\2\u17e7\u17e5\3\2\2\2\u17e8\u17f1\3\2\2\2\u17e9") + buf.write("\u17ea\7\u0245\2\2\u17ea\u17ef\7\u00ef\2\2\u17eb\u17f0") + buf.write("\7\u0125\2\2\u17ec\u17f0\7\u0098\2\2\u17ed\u17ee\7\u0098") + buf.write("\2\2\u17ee\u17f0\7\u0117\2\2\u17ef\u17eb\3\2\2\2\u17ef") + buf.write("\u17ec\3\2\2\2\u17ef\u17ed\3\2\2\2\u17f0\u17f2\3\2\2\2") + buf.write("\u17f1\u17e9\3\2\2\2\u17f1\u17f2\3\2\2\2\u17f2\u17f3\3") + buf.write("\2\2\2\u17f3\u17f4\7\u024c\2\2\u17f4\u183f\3\2\2\2\u17f5") + buf.write("\u17f6\7\u0151\2\2\u17f6\u17f7\7\u024b\2\2\u17f7\u17f8") + buf.write("\5\u0230\u0119\2\u17f8\u17fb\7\u00af\2\2\u17f9\u17fa\7") + buf.write("\26\2\2\u17fa\u17fc\7\u00c4\2\2\u17fb\u17f9\3\2\2\2\u17fb") + buf.write("\u17fc\3\2\2\2\u17fc\u17fd\3\2\2\2\u17fd\u1800\5\u0230") + buf.write("\u0119\2\u17fe\u17ff\7\26\2\2\u17ff\u1801\7\u00c4\2\2") + buf.write("\u1800\u17fe\3\2\2\2\u1800\u1801\3\2\2\2\u1801\u1802\3") + buf.write("\2\2\2\u1802\u1803\7\u024c\2\2\u1803\u183f\3\2\2\2\u1804") + buf.write("\u1805\7\u0154\2\2\u1805\u1806\7\u024b\2\2\u1806\u1807") + buf.write("\t*\2\2\u1807\u1808\5\u0230\u0119\2\u1808\u1809\7\u024c") + buf.write("\2\2\u1809\u183f\3\2\2\2\u180a\u180b\7\u0157\2\2\u180b") + buf.write("\u180c\7\u024b\2\2\u180c\u180d\t*\2\2\u180d\u180e\5\u0230") + buf.write("\u0119\2\u180e\u180f\7\u0176\2\2\u180f\u1810\5\u0224\u0113") + buf.write("\2\u1810\u1811\7\u024c\2\2\u1811\u183f\3\2\2\2\u1812\u1813") + buf.write("\7\u0158\2\2\u1813\u1826\7\u024b\2\2\u1814\u1815\7\u0153") + buf.write("\2\2\u1815\u1816\7\u024b\2\2\u1816\u1817\5\u0230\u0119") + buf.write("\2\u1817\u1818\7\u0176\2\2\u1818\u1820\5\u0210\u0109\2") + buf.write("\u1819\u181a\7\u0245\2\2\u181a\u181b\5\u0230\u0119\2\u181b") + buf.write("\u181c\7\u0176\2\2\u181c\u181d\5\u0210\u0109\2\u181d\u181f") + buf.write("\3\2\2\2\u181e\u1819\3\2\2\2\u181f\u1822\3\2\2\2\u1820") + buf.write("\u181e\3\2\2\2\u1820\u1821\3\2\2\2\u1821\u1823\3\2\2\2") + buf.write("\u1822\u1820\3\2\2\2\u1823\u1824\7\u024c\2\2\u1824\u1825") + buf.write("\7\u0245\2\2\u1825\u1827\3\2\2\2\u1826\u1814\3\2\2\2\u1826") + buf.write("\u1827\3\2\2\2\u1827\u1828\3\2\2\2\u1828\u1829\5\u0230") + buf.write("\u0119\2\u1829\u182c\7\u00af\2\2\u182a\u182b\7\26\2\2") + buf.write("\u182b\u182d\7\u00c4\2\2\u182c\u182a\3\2\2\2\u182c\u182d") + buf.write("\3\2\2\2\u182d\u182e\3\2\2\2\u182e\u1831\5\u0230\u0119") + buf.write("\2\u182f\u1830\7\26\2\2\u1830\u1832\7\u00c4\2\2\u1831") + buf.write("\u182f\3\2\2\2\u1831\u1832\3\2\2\2\u1832\u1833\3\2\2\2") + buf.write("\u1833\u1834\7#\2\2\u1834\u1839\5\u0258\u012d\2\u1835") + buf.write("\u1836\7\u0245\2\2\u1836\u1838\5\u0258\u012d\2\u1837\u1835") + buf.write("\3\2\2\2\u1838\u183b\3\2\2\2\u1839\u1837\3\2\2\2\u1839") + buf.write("\u183a\3\2\2\2\u183a\u183c\3\2\2\2\u183b\u1839\3\2\2\2") + buf.write("\u183c\u183d\7\u024c\2\2\u183d\u183f\3\2\2\2\u183e\u179d") + buf.write("\3\2\2\2\u183e\u17c1\3\2\2\2\u183e\u17d5\3\2\2\2\u183e") + buf.write("\u17df\3\2\2\2\u183e\u17f5\3\2\2\2\u183e\u1804\3\2\2\2") + buf.write("\u183e\u180a\3\2\2\2\u183e\u1812\3\2\2\2\u183f\u0257\3") + buf.write("\2\2\2\u1840\u1852\5\u0210\u0109\2\u1841\u1844\5\u0224") + buf.write("\u0113\2\u1842\u1843\7\u01fd\2\2\u1843\u1845\5\u0230\u0119") + buf.write("\2\u1844\u1842\3\2\2\2\u1844\u1845\3\2\2\2\u1845\u1848") + buf.write("\3\2\2\2\u1846\u1847\7\u0187\2\2\u1847\u1849\5\u0230\u0119") + buf.write("\2\u1848\u1846\3\2\2\2\u1848\u1849\3\2\2\2\u1849\u184e") + buf.write("\3\2\2\2\u184a\u184c\7\u01a0\2\2\u184b\u184a\3\2\2\2\u184b") + buf.write("\u184c\3\2\2\2\u184c\u184d\3\2\2\2\u184d\u184f\7\u01a1") + buf.write("\2\2\u184e\u184b\3\2\2\2\u184e\u184f\3\2\2\2\u184f\u1853") + buf.write("\3\2\2\2\u1850\u1851\7\u0191\2\2\u1851\u1853\7\u00a5\2") + buf.write("\2\u1852\u1841\3\2\2\2\u1852\u1850\3\2\2\2\u1853\u0259") + buf.write("\3\2\2\2\u1854\u1855\tX\2\2\u1855\u1858\7\u024b\2\2\u1856") + buf.write("\u1859\5\u0230\u0119\2\u1857\u1859\5\u0274\u013b\2\u1858") + buf.write("\u1856\3\2\2\2\u1858\u1857\3\2\2\2\u1859\u185a\3\2\2\2") + buf.write("\u185a\u185b\7\u024c\2\2\u185b\u025b\3\2\2\2\u185c\u185d") + buf.write("\7Y\2\2\u185d\u185e\7\u024b\2\2\u185e\u185f\7\u01ba\2") + buf.write("\2\u185f\u1860\5\u0230\u0119\2\u1860\u1861\7\u024c\2\2") + buf.write("\u1861\u025d\3\2\2\2\u1862\u1864\7\u024b\2\2\u1863\u1865") + buf.write("\5\u0210\u0109\2\u1864\u1863\3\2\2\2\u1864\u1865\3\2\2") + buf.write("\2\u1865\u1867\3\2\2\2\u1866\u1868\5\u01f6\u00fc\2\u1867") + buf.write("\u1866\3\2\2\2\u1867\u1868\3\2\2\2\u1868\u186a\3\2\2\2") + buf.write("\u1869\u186b\5\u0298\u014d\2\u186a\u1869\3\2\2\2\u186a") + buf.write("\u186b\3\2\2\2\u186b\u186d\3\2\2\2\u186c\u186e\5\u0260") + buf.write("\u0131\2\u186d\u186c\3\2\2\2\u186d\u186e\3\2\2\2\u186e") + buf.write("\u186f\3\2\2\2\u186f\u1870\7\u024c\2\2\u1870\u025f\3\2") + buf.write("\2\2\u1871\u1878\tY\2\2\u1872\u1879\5\u0262\u0132\2\u1873") + buf.write("\u1874\7\u0127\2\2\u1874\u1875\5\u0262\u0132\2\u1875\u1876") + buf.write("\7\u0173\2\2\u1876\u1877\5\u0262\u0132\2\u1877\u1879\3") + buf.write("\2\2\2\u1878\u1872\3\2\2\2\u1878\u1873\3\2\2\2\u1879\u1883") + buf.write("\3\2\2\2\u187a\u1881\7Q\2\2\u187b\u187c\7\63\2\2\u187c") + buf.write("\u1882\7\u0144\2\2\u187d\u1882\7\u0195\2\2\u187e\u1882") + buf.write("\7\u0103\2\2\u187f\u1880\7\u0098\2\2\u1880\u1882\7\u00a6") + buf.write("\2\2\u1881\u187b\3\2\2\2\u1881\u187d\3\2\2\2\u1881\u187e") + buf.write("\3\2\2\2\u1881\u187f\3\2\2\2\u1882\u1884\3\2\2\2\u1883") + buf.write("\u187a\3\2\2\2\u1883\u1884\3\2\2\2\u1884\u0261\3\2\2\2") + buf.write("\u1885\u1886\5\u0230\u0119\2\u1886\u1887\tZ\2\2\u1887") + buf.write("\u188b\3\2\2\2\u1888\u1889\7\63\2\2\u1889\u188b\7\u0144") + buf.write("\2\2\u188a\u1885\3\2\2\2\u188a\u1888\3\2\2\2\u188b\u0263") + buf.write("\3\2\2\2\u188c\u188f\7\u0175\2\2\u188d\u1890\5\u0266\u0134") + buf.write("\2\u188e\u1890\5\u026e\u0138\2\u188f\u188d\3\2\2\2\u188f") + buf.write("\u188e\3\2\2\2\u1890\u0265\3\2\2\2\u1891\u18a0\7\u0257") + buf.write("\2\2\u1892\u1895\5\u0230\u0119\2\u1893\u1895\5\u0266\u0134") + buf.write("\2\u1894\u1892\3\2\2\2\u1894\u1893\3\2\2\2\u1895\u189d") + buf.write("\3\2\2\2\u1896\u1899\7\u0245\2\2\u1897\u189a\5\u0230\u0119") + buf.write("\2\u1898\u189a\5\u0266\u0134\2\u1899\u1897\3\2\2\2\u1899") + buf.write("\u1898\3\2\2\2\u189a\u189c\3\2\2\2\u189b\u1896\3\2\2\2") + buf.write("\u189c\u189f\3\2\2\2\u189d\u189b\3\2\2\2\u189d\u189e\3") + buf.write("\2\2\2\u189e\u18a1\3\2\2\2\u189f\u189d\3\2\2\2\u18a0\u1894") + buf.write("\3\2\2\2\u18a0\u18a1\3\2\2\2\u18a1\u18a2\3\2\2\2\u18a2") + buf.write("\u18a3\7\u0258\2\2\u18a3\u0267\3\2\2\2\u18a4\u18a5\5\u0224") + buf.write("\u0113\2\u18a5\u18a6\5\u0146\u00a4\2\u18a6\u18ae\3\2\2") + buf.write("\2\u18a7\u18a8\7\u0138\2\2\u18a8\u18a9\5\u0146\u00a4\2") + buf.write("\u18a9\u18ab\5\u022a\u0116\2\u18aa\u18ac\5\u022c\u0117") + buf.write("\2\u18ab\u18aa\3\2\2\2\u18ab\u18ac\3\2\2\2\u18ac\u18ae") + buf.write("\3\2\2\2\u18ad\u18a4\3\2\2\2\u18ad\u18a7\3\2\2\2\u18ae") + buf.write("\u0269\3\2\2\2\u18af\u18b6\5\u0210\u0109\2\u18b0\u18b1") + buf.write("\7\u0253\2\2\u18b1\u18b4\5\u0210\u0109\2\u18b2\u18b3\7") + buf.write("\u0253\2\2\u18b3\u18b5\5\u0210\u0109\2\u18b4\u18b2\3\2") + buf.write("\2\2\u18b4\u18b5\3\2\2\2\u18b5\u18b7\3\2\2\2\u18b6\u18b0") + buf.write("\3\2\2\2\u18b6\u18b7\3\2\2\2\u18b7\u026b\3\2\2\2\u18b8") + buf.write("\u18b9\t[\2\2\u18b9\u026d\3\2\2\2\u18ba\u18bb\7\u024b") + buf.write("\2\2\u18bb\u18bc\5\u0270\u0139\2\u18bc\u18bd\7\u024c\2") + buf.write("\2\u18bd\u026f\3\2\2\2\u18be\u18c0\5\u0276\u013c\2\u18bf") + buf.write("\u18be\3\2\2\2\u18bf\u18c0\3\2\2\2\u18c0\u18c1\3\2\2\2") + buf.write("\u18c1\u18c5\5\u027a\u013e\2\u18c2\u18c4\5\u0272\u013a") + buf.write("\2\u18c3\u18c2\3\2\2\2\u18c4\u18c7\3\2\2\2\u18c5\u18c3") + buf.write("\3\2\2\2\u18c5\u18c6\3\2\2\2\u18c6\u0271\3\2\2\2\u18c7") + buf.write("\u18c5\3\2\2\2\u18c8\u18f7\5\u0298\u014d\2\u18c9\u18cc") + buf.write("\7\u019d\2\2\u18ca\u18cd\5\u0230\u0119\2\u18cb\u18cd\7") + buf.write("\u0170\2\2\u18cc\u18ca\3\2\2\2\u18cc\u18cb\3\2\2\2\u18cd") + buf.write("\u18f7\3\2\2\2\u18ce\u18cf\7\u01a2\2\2\u18cf\u18d1\5\u0230") + buf.write("\u0119\2\u18d0\u18d2\t\\\2\2\u18d1\u18d0\3\2\2\2\u18d1") + buf.write("\u18d2\3\2\2\2\u18d2\u18f7\3\2\2\2\u18d3\u18d4\7\u0190") + buf.write("\2\2\u18d4\u18d6\t]\2\2\u18d5\u18d7\5\u0230\u0119\2\u18d6") + buf.write("\u18d5\3\2\2\2\u18d6\u18d7\3\2\2\2\u18d7\u18d8\3\2\2\2") + buf.write("\u18d8\u18da\t\\\2\2\u18d9\u18db\7\u01a4\2\2\u18da\u18d9") + buf.write("\3\2\2\2\u18da\u18db\3\2\2\2\u18db\u18f7\3\2\2\2\u18dc") + buf.write("\u18e4\7\u0191\2\2\u18dd\u18e5\7\u0112\2\2\u18de\u18df") + buf.write("\7\u0098\2\2\u18df\u18e0\7|\2\2\u18e0\u18e5\7\u0112\2") + buf.write("\2\u18e1\u18e5\7\u00e8\2\2\u18e2\u18e3\7|\2\2\u18e3\u18e5") + buf.write("\7\u00e8\2\2\u18e4\u18dd\3\2\2\2\u18e4\u18de\3\2\2\2\u18e4") + buf.write("\u18e1\3\2\2\2\u18e4\u18e2\3\2\2\2\u18e5\u18ef\3\2\2\2") + buf.write("\u18e6\u18e7\7\u009e\2\2\u18e7\u18ec\5\u026a\u0136\2\u18e8") + buf.write("\u18e9\7\u0245\2\2\u18e9\u18eb\5\u026a\u0136\2\u18ea\u18e8") + buf.write("\3\2\2\2\u18eb\u18ee\3\2\2\2\u18ec\u18ea\3\2\2\2\u18ec") + buf.write("\u18ed\3\2\2\2\u18ed\u18f0\3\2\2\2\u18ee\u18ec\3\2\2\2") + buf.write("\u18ef\u18e6\3\2\2\2\u18ef\u18f0\3\2\2\2\u18f0\u18f4\3") + buf.write("\2\2\2\u18f1\u18f5\7\u009b\2\2\u18f2\u18f3\7\u00eb\2\2") + buf.write("\u18f3\u18f5\7\u0088\2\2\u18f4\u18f1\3\2\2\2\u18f4\u18f2") + buf.write("\3\2\2\2\u18f4\u18f5\3\2\2\2\u18f5\u18f7\3\2\2\2\u18f6") + buf.write("\u18c8\3\2\2\2\u18f6\u18c9\3\2\2\2\u18f6\u18ce\3\2\2\2") + buf.write("\u18f6\u18d3\3\2\2\2\u18f6\u18dc\3\2\2\2\u18f7\u0273\3") + buf.write("\2\2\2\u18f8\u18fa\5\u0276\u013c\2\u18f9\u18f8\3\2\2\2") + buf.write("\u18f9\u18fa\3\2\2\2\u18fa\u18fb\3\2\2\2\u18fb\u18ff\5") + buf.write("\u027c\u013f\2\u18fc\u18fe\5\u0272\u013a\2\u18fd\u18fc") + buf.write("\3\2\2\2\u18fe\u1901\3\2\2\2\u18ff\u18fd\3\2\2\2\u18ff") + buf.write("\u1900\3\2\2\2\u1900\u0275\3\2\2\2\u1901\u18ff\3\2\2\2") + buf.write("\u1902\u1904\7\u01bc\2\2\u1903\u1905\7\u00c3\2\2\u1904") + buf.write("\u1903\3\2\2\2\u1904\u1905\3\2\2\2\u1905\u1906\3\2\2\2") + buf.write("\u1906\u190b\5\u0278\u013d\2\u1907\u1908\7\u0245\2\2\u1908") + buf.write("\u190a\5\u0278\u013d\2\u1909\u1907\3\2\2\2\u190a\u190d") + buf.write("\3\2\2\2\u190b\u1909\3\2\2\2\u190b\u190c\3\2\2\2\u190c") + buf.write("\u0277\3\2\2\2\u190d\u190b\3\2\2\2\u190e\u191a\5\u0210") + buf.write("\u0109\2\u190f\u1910\7\u024b\2\2\u1910\u1915\5\u0210\u0109") + buf.write("\2\u1911\u1912\7\u0245\2\2\u1912\u1914\5\u0210\u0109\2") + buf.write("\u1913\u1911\3\2\2\2\u1914\u1917\3\2\2\2\u1915\u1913\3") + buf.write("\2\2\2\u1915\u1916\3\2\2\2\u1916\u1918\3\2\2\2\u1917\u1915") + buf.write("\3\2\2\2\u1918\u1919\7\u024c\2\2\u1919\u191b\3\2\2\2\u191a") + buf.write("\u190f\3\2\2\2\u191a\u191b\3\2\2\2\u191b\u191c\3\2\2\2") + buf.write("\u191c\u1921\7\u0176\2\2\u191d\u191f\7\u01a0\2\2\u191e") + buf.write("\u191d\3\2\2\2\u191e\u191f\3\2\2\2\u191f\u1920\3\2\2\2") + buf.write("\u1920\u1922\7\u008c\2\2\u1921\u191e\3\2\2\2\u1921\u1922") + buf.write("\3\2\2\2\u1922\u1923\3\2\2\2\u1923\u1924\7\u024b\2\2\u1924") + buf.write("\u1925\5\20\t\2\u1925\u1926\7\u024c\2\2\u1926\u0279\3") + buf.write("\2\2\2\u1927\u1928\b\u013e\1\2\u1928\u1929\7\u024b\2\2") + buf.write("\u1929\u192a\5\u0270\u0139\2\u192a\u192b\7\u024c\2\2\u192b") + buf.write("\u192e\3\2\2\2\u192c\u192e\5\u027e\u0140\2\u192d\u1927") + buf.write("\3\2\2\2\u192d\u192c\3\2\2\2\u192e\u1937\3\2\2\2\u192f") + buf.write("\u1930\f\4\2\2\u1930\u1932\t^\2\2\u1931\u1933\5\u026c") + buf.write("\u0137\2\u1932\u1931\3\2\2\2\u1932\u1933\3\2\2\2\u1933") + buf.write("\u1934\3\2\2\2\u1934\u1936\5\u027a\u013e\5\u1935\u192f") + buf.write("\3\2\2\2\u1936\u1939\3\2\2\2\u1937\u1935\3\2\2\2\u1937") + buf.write("\u1938\3\2\2\2\u1938\u027b\3\2\2\2\u1939\u1937\3\2\2\2") + buf.write("\u193a\u193b\5\u027a\u013e\2\u193b\u193d\t^\2\2\u193c") + buf.write("\u193e\5\u026c\u0137\2\u193d\u193c\3\2\2\2\u193d\u193e") + buf.write("\3\2\2\2\u193e\u1944\3\2\2\2\u193f\u1945\5\u027e\u0140") + buf.write("\2\u1940\u1941\7\u024b\2\2\u1941\u1942\5\u0270\u0139\2") + buf.write("\u1942\u1943\7\u024c\2\2\u1943\u1945\3\2\2\2\u1944\u193f") + buf.write("\3\2\2\2\u1944\u1940\3\2\2\2\u1945\u1948\3\2\2\2\u1946") + buf.write("\u1948\5\u027e\u0140\2\u1947\u193a\3\2\2\2\u1947\u1946") + buf.write("\3\2\2\2\u1948\u027d\3\2\2\2\u1949\u1959\7\u01ab\2\2\u194a") + buf.write("\u1957\5\u026c\u0137\2\u194b\u194c\7\u01a3\2\2\u194c\u194d") + buf.write("\7\u024b\2\2\u194d\u1952\5\u0230\u0119\2\u194e\u194f\7") + buf.write("\u0245\2\2\u194f\u1951\5\u0230\u0119\2\u1950\u194e\3\2") + buf.write("\2\2\u1951\u1954\3\2\2\2\u1952\u1950\3\2\2\2\u1952\u1953") + buf.write("\3\2\2\2\u1953\u1955\3\2\2\2\u1954\u1952\3\2\2\2\u1955") + buf.write("\u1956\7\u024c\2\2\u1956\u1958\3\2\2\2\u1957\u194b\3\2") + buf.write("\2\2\u1957\u1958\3\2\2\2\u1958\u195a\3\2\2\2\u1959\u194a") + buf.write("\3\2\2\2\u1959\u195a\3\2\2\2\u195a\u195c\3\2\2\2\u195b") + buf.write("\u195d\5\u0280\u0141\2\u195c\u195b\3\2\2\2\u195c\u195d") + buf.write("\3\2\2\2\u195d\u195f\3\2\2\2\u195e\u1960\5\u0284\u0143") + buf.write("\2\u195f\u195e\3\2\2\2\u195f\u1960\3\2\2\2\u1960\u196a") + buf.write("\3\2\2\2\u1961\u1962\7\u0193\2\2\u1962\u1967\5\u0286\u0144") + buf.write("\2\u1963\u1964\7\u0245\2\2\u1964\u1966\5\u0286\u0144\2") + buf.write("\u1965\u1963\3\2\2\2\u1966\u1969\3\2\2\2\u1967\u1965\3") + buf.write("\2\2\2\u1967\u1968\3\2\2\2\u1968\u196b\3\2\2\2\u1969\u1967") + buf.write("\3\2\2\2\u196a\u1961\3\2\2\2\u196a\u196b\3\2\2\2\u196b") + buf.write("\u196e\3\2\2\2\u196c\u196d\7\u01ba\2\2\u196d\u196f\5\u0230") + buf.write("\u0119\2\u196e\u196c\3\2\2\2\u196e\u196f\3\2\2\2\u196f") + buf.write("\u1971\3\2\2\2\u1970\u1972\5\u028e\u0148\2\u1971\u1970") + buf.write("\3\2\2\2\u1971\u1972\3\2\2\2\u1972\u1975\3\2\2\2\u1973") + buf.write("\u1974\7\u0196\2\2\u1974\u1976\5\u0230\u0119\2\u1975\u1973") + buf.write("\3\2\2\2\u1975\u1976\3\2\2\2\u1976\u1985\3\2\2\2\u1977") + buf.write("\u1978\7\u01bb\2\2\u1978\u1979\5\u0210\u0109\2\u1979\u197a") + buf.write("\7\u0176\2\2\u197a\u1982\5\u025e\u0130\2\u197b\u197c\7") + buf.write("\u0245\2\2\u197c\u197d\5\u0210\u0109\2\u197d\u197e\7\u0176") + buf.write("\2\2\u197e\u197f\5\u025e\u0130\2\u197f\u1981\3\2\2\2\u1980") + buf.write("\u197b\3\2\2\2\u1981\u1984\3\2\2\2\u1982\u1980\3\2\2\2") + buf.write("\u1982\u1983\3\2\2\2\u1983\u1986\3\2\2\2\u1984\u1982\3") + buf.write("\2\2\2\u1985\u1977\3\2\2\2\u1985\u1986\3\2\2\2\u1986\u1991") + buf.write("\3\2\2\2\u1987\u1989\7\u01af\2\2\u1988\u198a\7\u01a4\2") + buf.write("\2\u1989\u1988\3\2\2\2\u1989\u198a\3\2\2\2\u198a\u198b") + buf.write("\3\2\2\2\u198b\u198d\5\u026a\u0136\2\u198c\u198e\7\u024f") + buf.write("\2\2\u198d\u198c\3\2\2\2\u198d\u198e\3\2\2\2\u198e\u1991") + buf.write("\3\2\2\2\u198f\u1991\5\u0294\u014b\2\u1990\u1949\3\2\2") + buf.write("\2\u1990\u1987\3\2\2\2\u1990\u198f\3\2\2\2\u1991\u027f") + buf.write("\3\2\2\2\u1992\u1997\5\u0282\u0142\2\u1993\u1994\7\u0245") + buf.write("\2\2\u1994\u1996\5\u0282\u0142\2\u1995\u1993\3\2\2\2\u1996") + buf.write("\u1999\3\2\2\2\u1997\u1995\3\2\2\2\u1997\u1998\3\2\2\2") + buf.write("\u1998\u0281\3\2\2\2\u1999\u1997\3\2\2\2\u199a\u199e\5") + buf.write("\u0230\u0119\2\u199b\u199c\7\u0176\2\2\u199c\u199f\5\u0214") + buf.write("\u010b\2\u199d\u199f\5\u020e\u0108\2\u199e\u199b\3\2\2") + buf.write("\2\u199e\u199d\3\2\2\2\u199e\u199f\3\2\2\2\u199f\u0283") + buf.write("\3\2\2\2\u19a0\u19a2\7\u019a\2\2\u19a1\u19a3\t_\2\2\u19a2") + buf.write("\u19a1\3\2\2\2\u19a2\u19a3\3\2\2\2\u19a3\u19a5\3\2\2\2") + buf.write("\u19a4\u19a6\7\u01af\2\2\u19a5\u19a4\3\2\2\2\u19a5\u19a6") + buf.write("\3\2\2\2\u19a6\u19a7\3\2\2\2\u19a7\u19a8\5\u026a\u0136") + buf.write("\2\u19a8\u0285\3\2\2\2\u19a9\u19aa\b\u0144\1\2\u19aa\u19ab") + buf.write("\7\u024b\2\2\u19ab\u19ac\5\u0286\u0144\2\u19ac\u19ae\7") + buf.write("\u024c\2\2\u19ad\u19af\5\u028a\u0146\2\u19ae\u19ad\3\2") + buf.write("\2\2\u19ae\u19af\3\2\2\2\u19af\u19b2\3\2\2\2\u19b0\u19b2") + buf.write("\5\u0288\u0145\2\u19b1\u19a9\3\2\2\2\u19b1\u19b0\3\2\2") + buf.write("\2\u19b2\u19de\3\2\2\2\u19b3\u19b4\f\7\2\2\u19b4\u19b5") + buf.write("\7\u015d\2\2\u19b5\u19b6\7\u0165\2\2\u19b6\u19dd\5\u0286") + buf.write("\u0144\b\u19b7\u19b8\f\4\2\2\u19b8\u19be\7\u0168\2\2\u19b9") + buf.write("\u19bf\7\u0162\2\2\u19ba\u19bc\t`\2\2\u19bb\u19bd\7\u016a") + buf.write("\2\2\u19bc\u19bb\3\2\2\2\u19bc\u19bd\3\2\2\2\u19bd\u19bf") + buf.write("\3\2\2\2\u19be\u19b9\3\2\2\2\u19be\u19ba\3\2\2\2\u19be") + buf.write("\u19bf\3\2\2\2\u19bf\u19c0\3\2\2\2\u19c0\u19c1\7\u0165") + buf.write("\2\2\u19c1\u19dd\5\u0286\u0144\5\u19c2\u19c8\f\6\2\2\u19c3") + buf.write("\u19c9\7\u0162\2\2\u19c4\u19c6\t`\2\2\u19c5\u19c7\7\u016a") + buf.write("\2\2\u19c6\u19c5\3\2\2\2\u19c6\u19c7\3\2\2\2\u19c7\u19c9") + buf.write("\3\2\2\2\u19c8\u19c3\3\2\2\2\u19c8\u19c4\3\2\2\2\u19c8") + buf.write("\u19c9\3\2\2\2\u19c9\u19ca\3\2\2\2\u19ca\u19cb\7\u0165") + buf.write("\2\2\u19cb\u19cc\5\u0286\u0144\2\u19cc\u19cd\7\u01a3\2") + buf.write("\2\u19cd\u19ce\5\u0230\u0119\2\u19ce\u19dd\3\2\2\2\u19cf") + buf.write("\u19d5\f\5\2\2\u19d0\u19d6\7\u0162\2\2\u19d1\u19d3\t`") + buf.write("\2\2\u19d2\u19d4\7\u016a\2\2\u19d3\u19d2\3\2\2\2\u19d3") + buf.write("\u19d4\3\2\2\2\u19d4\u19d6\3\2\2\2\u19d5\u19d0\3\2\2\2") + buf.write("\u19d5\u19d1\3\2\2\2\u19d5\u19d6\3\2\2\2\u19d6\u19d7\3") + buf.write("\2\2\2\u19d7\u19d8\7\u0165\2\2\u19d8\u19d9\5\u0286\u0144") + buf.write("\2\u19d9\u19da\7\u01b7\2\2\u19da\u19db\5\u01d8\u00ed\2") + buf.write("\u19db\u19dd\3\2\2\2\u19dc\u19b3\3\2\2\2\u19dc\u19b7\3") + buf.write("\2\2\2\u19dc\u19c2\3\2\2\2\u19dc\u19cf\3\2\2\2\u19dd\u19e0") + buf.write("\3\2\2\2\u19de\u19dc\3\2\2\2\u19de\u19df\3\2\2\2\u19df") + buf.write("\u0287\3\2\2\2\u19e0\u19de\3\2\2\2\u19e1\u19e3\7\u01a4") + buf.write("\2\2\u19e2\u19e1\3\2\2\2\u19e2\u19e3\3\2\2\2\u19e3\u19e4") + buf.write("\3\2\2\2\u19e4\u19e6\5\u026a\u0136\2\u19e5\u19e7\7\u024f") + buf.write("\2\2\u19e6\u19e5\3\2\2\2\u19e6\u19e7\3\2\2\2\u19e7\u19e9") + buf.write("\3\2\2\2\u19e8\u19ea\5\u028a\u0146\2\u19e9\u19e8\3\2\2") + buf.write("\2\u19e9\u19ea\3\2\2\2\u19ea\u19fb\3\2\2\2\u19eb\u19ec") + buf.write("\7\u016e\2\2\u19ec\u19ed\5\u0210\u0109\2\u19ed\u19ee\7") + buf.write("\u024b\2\2\u19ee\u19f3\5\u0230\u0119\2\u19ef\u19f0\7\u0245") + buf.write("\2\2\u19f0\u19f2\5\u0230\u0119\2\u19f1\u19ef\3\2\2\2\u19f2") + buf.write("\u19f5\3\2\2\2\u19f3\u19f1\3\2\2\2\u19f3\u19f4\3\2\2\2") + buf.write("\u19f4\u19f6\3\2\2\2\u19f5\u19f3\3\2\2\2\u19f6\u19f9\7") + buf.write("\u024c\2\2\u19f7\u19f8\7\u00cb\2\2\u19f8\u19fa\5\u0230") + buf.write("\u0119\2\u19f9\u19f7\3\2\2\2\u19f9\u19fa\3\2\2\2\u19fa") + buf.write("\u19fc\3\2\2\2\u19fb\u19eb\3\2\2\2\u19fb\u19fc\3\2\2\2") + buf.write("\u19fc\u1a50\3\2\2\2\u19fd\u19ff\7\u019b\2\2\u19fe\u19fd") + buf.write("\3\2\2\2\u19fe\u19ff\3\2\2\2\u19ff\u1a00\3\2\2\2\u1a00") + buf.write("\u1a01\5\u026e\u0138\2\u1a01\u1a02\5\u028a\u0146\2\u1a02") + buf.write("\u1a50\3\2\2\2\u1a03\u1a05\7\u019b\2\2\u1a04\u1a03\3\2") + buf.write("\2\2\u1a04\u1a05\3\2\2\2\u1a05\u1a06\3\2\2\2\u1a06\u1a09") + buf.write("\5\u0246\u0124\2\u1a07\u1a08\7\u01bc\2\2\u1a08\u1a0a\7") + buf.write("\u00a5\2\2\u1a09\u1a07\3\2\2\2\u1a09\u1a0a\3\2\2\2\u1a0a") + buf.write("\u1a1f\3\2\2\2\u1a0b\u1a0c\7\u0176\2\2\u1a0c\u1a20\5\u028c") + buf.write("\u0147\2\u1a0d\u1a0f\7\u0176\2\2\u1a0e\u1a0d\3\2\2\2\u1a0e") + buf.write("\u1a0f\3\2\2\2\u1a0f\u1a10\3\2\2\2\u1a10\u1a1d\5\u0210") + buf.write("\u0109\2\u1a11\u1a12\7\u024b\2\2\u1a12\u1a17\5\u0210\u0109") + buf.write("\2\u1a13\u1a14\7\u0245\2\2\u1a14\u1a16\5\u0210\u0109\2") + buf.write("\u1a15\u1a13\3\2\2\2\u1a16\u1a19\3\2\2\2\u1a17\u1a15\3") + buf.write("\2\2\2\u1a17\u1a18\3\2\2\2\u1a18\u1a1a\3\2\2\2\u1a19\u1a17") + buf.write("\3\2\2\2\u1a1a\u1a1b\7\u024c\2\2\u1a1b\u1a1e\3\2\2\2\u1a1c") + buf.write("\u1a1e\5\u028c\u0147\2\u1a1d\u1a11\3\2\2\2\u1a1d\u1a1c") + buf.write("\3\2\2\2\u1a1d\u1a1e\3\2\2\2\u1a1e\u1a20\3\2\2\2\u1a1f") + buf.write("\u1a0b\3\2\2\2\u1a1f\u1a0e\3\2\2\2\u1a1f\u1a20\3\2\2\2") + buf.write("\u1a20\u1a50\3\2\2\2\u1a21\u1a23\7\u019b\2\2\u1a22\u1a21") + buf.write("\3\2\2\2\u1a22\u1a23\3\2\2\2\u1a23\u1a24\3\2\2\2\u1a24") + buf.write("\u1a25\7\u00d8\2\2\u1a25\u1a26\7\u0193\2\2\u1a26\u1a27") + buf.write("\7\u024b\2\2\u1a27\u1a2a\5\u0246\u0124\2\u1a28\u1a29\7") + buf.write("\u0176\2\2\u1a29\u1a2b\5\u028c\u0147\2\u1a2a\u1a28\3\2") + buf.write("\2\2\u1a2a\u1a2b\3\2\2\2\u1a2b\u1a34\3\2\2\2\u1a2c\u1a2d") + buf.write("\7\u0245\2\2\u1a2d\u1a30\5\u0246\u0124\2\u1a2e\u1a2f\7") + buf.write("\u0176\2\2\u1a2f\u1a31\5\u028c\u0147\2\u1a30\u1a2e\3\2") + buf.write("\2\2\u1a30\u1a31\3\2\2\2\u1a31\u1a33\3\2\2\2\u1a32\u1a2c") + buf.write("\3\2\2\2\u1a33\u1a36\3\2\2\2\u1a34\u1a32\3\2\2\2\u1a34") + buf.write("\u1a35\3\2\2\2\u1a35\u1a37\3\2\2\2\u1a36\u1a34\3\2\2\2") + buf.write("\u1a37\u1a3a\7\u024c\2\2\u1a38\u1a39\7\u01bc\2\2\u1a39") + buf.write("\u1a3b\7\u00a5\2\2\u1a3a\u1a38\3\2\2\2\u1a3a\u1a3b\3\2") + buf.write("\2\2\u1a3b\u1a4d\3\2\2\2\u1a3c\u1a3e\7\u0176\2\2\u1a3d") + buf.write("\u1a3c\3\2\2\2\u1a3d\u1a3e\3\2\2\2\u1a3e\u1a3f\3\2\2\2") + buf.write("\u1a3f\u1a4b\5\u0210\u0109\2\u1a40\u1a41\7\u024b\2\2\u1a41") + buf.write("\u1a46\5\u0210\u0109\2\u1a42\u1a43\7\u0245\2\2\u1a43\u1a45") + buf.write("\5\u0210\u0109\2\u1a44\u1a42\3\2\2\2\u1a45\u1a48\3\2\2") + buf.write("\2\u1a46\u1a44\3\2\2\2\u1a46\u1a47\3\2\2\2\u1a47\u1a49") + buf.write("\3\2\2\2\u1a48\u1a46\3\2\2\2\u1a49\u1a4a\7\u024c\2\2\u1a4a") + buf.write("\u1a4c\3\2\2\2\u1a4b\u1a40\3\2\2\2\u1a4b\u1a4c\3\2\2\2") + buf.write("\u1a4c\u1a4e\3\2\2\2\u1a4d\u1a3d\3\2\2\2\u1a4d\u1a4e\3") + buf.write("\2\2\2\u1a4e\u1a50\3\2\2\2\u1a4f\u19e2\3\2\2\2\u1a4f\u19fe") + buf.write("\3\2\2\2\u1a4f\u1a04\3\2\2\2\u1a4f\u1a22\3\2\2\2\u1a50") + buf.write("\u0289\3\2\2\2\u1a51\u1a53\7\u0176\2\2\u1a52\u1a51\3\2") + buf.write("\2\2\u1a52\u1a53\3\2\2\2\u1a53\u1a54\3\2\2\2\u1a54\u1a60") + buf.write("\5\u0210\u0109\2\u1a55\u1a56\7\u024b\2\2\u1a56\u1a5b\5") + buf.write("\u0210\u0109\2\u1a57\u1a58\7\u0245\2\2\u1a58\u1a5a\5\u0210") + buf.write("\u0109\2\u1a59\u1a57\3\2\2\2\u1a5a\u1a5d\3\2\2\2\u1a5b") + buf.write("\u1a59\3\2\2\2\u1a5b\u1a5c\3\2\2\2\u1a5c\u1a5e\3\2\2\2") + buf.write("\u1a5d\u1a5b\3\2\2\2\u1a5e\u1a5f\7\u024c\2\2\u1a5f\u1a61") + buf.write("\3\2\2\2\u1a60\u1a55\3\2\2\2\u1a60\u1a61\3\2\2\2\u1a61") + buf.write("\u028b\3\2\2\2\u1a62\u1a63\7\u024b\2\2\u1a63\u1a64\5\u0210") + buf.write("\u0109\2\u1a64\u1a6b\5\u0224\u0113\2\u1a65\u1a66\7\u0245") + buf.write("\2\2\u1a66\u1a67\5\u0210\u0109\2\u1a67\u1a68\5\u0224\u0113") + buf.write("\2\u1a68\u1a6a\3\2\2\2\u1a69\u1a65\3\2\2\2\u1a6a\u1a6d") + buf.write("\3\2\2\2\u1a6b\u1a69\3\2\2\2\u1a6b\u1a6c\3\2\2\2\u1a6c") + buf.write("\u1a6e\3\2\2\2\u1a6d\u1a6b\3\2\2\2\u1a6e\u1a6f\7\u024c") + buf.write("\2\2\u1a6f\u028d\3\2\2\2\u1a70\u1a71\7\u0195\2\2\u1a71") + buf.write("\u1a72\7\26\2\2\u1a72\u1a73\5\u0290\u0149\2\u1a73\u028f") + buf.write("\3\2\2\2\u1a74\u1a79\5\u0292\u014a\2\u1a75\u1a76\7\u0245") + buf.write("\2\2\u1a76\u1a78\5\u0292\u014a\2\u1a77\u1a75\3\2\2\2\u1a78") + buf.write("\u1a7b\3\2\2\2\u1a79\u1a77\3\2\2\2\u1a79\u1a7a\3\2\2\2") + buf.write("\u1a7a\u0291\3\2\2\2\u1a7b\u1a79\3\2\2\2\u1a7c\u1a8a\5") + buf.write("\u0230\u0119\2\u1a7d\u1a7e\7\u024b\2\2\u1a7e\u1a8a\7\u024c") + buf.write("\2\2\u1a7f\u1a84\7\u00d5\2\2\u1a80\u1a84\7\62\2\2\u1a81") + buf.write("\u1a82\7\u0134\2\2\u1a82\u1a84\7\u00e7\2\2\u1a83\u1a7f") + buf.write("\3\2\2\2\u1a83\u1a80\3\2\2\2\u1a83\u1a81\3\2\2\2\u1a84") + buf.write("\u1a85\3\2\2\2\u1a85\u1a86\7\u024b\2\2\u1a86\u1a87\5\u0290") + buf.write("\u0149\2\u1a87\u1a88\7\u024c\2\2\u1a88\u1a8a\3\2\2\2\u1a89") + buf.write("\u1a7c\3\2\2\2\u1a89\u1a7d\3\2\2\2\u1a89\u1a83\3\2\2\2") + buf.write("\u1a8a\u0293\3\2\2\2\u1a8b\u1a8c\7\u014c\2\2\u1a8c\u1a91") + buf.write("\5\u0296\u014c\2\u1a8d\u1a8e\7\u0245\2\2\u1a8e\u1a90\5") + buf.write("\u0296\u014c\2\u1a8f\u1a8d\3\2\2\2\u1a90\u1a93\3\2\2\2") + buf.write("\u1a91\u1a8f\3\2\2\2\u1a91\u1a92\3\2\2\2\u1a92\u0295\3") + buf.write("\2\2\2\u1a93\u1a91\3\2\2\2\u1a94\u1a97\7\u024b\2\2\u1a95") + buf.write("\u1a98\5\u0230\u0119\2\u1a96\u1a98\7\u0187\2\2\u1a97\u1a95") + buf.write("\3\2\2\2\u1a97\u1a96\3\2\2\2\u1a98\u1aa0\3\2\2\2\u1a99") + buf.write("\u1a9c\7\u0245\2\2\u1a9a\u1a9d\5\u0230\u0119\2\u1a9b\u1a9d") + buf.write("\7\u0187\2\2\u1a9c\u1a9a\3\2\2\2\u1a9c\u1a9b\3\2\2\2\u1a9d") + buf.write("\u1a9f\3\2\2\2\u1a9e\u1a99\3\2\2\2\u1a9f\u1aa2\3\2\2\2") + buf.write("\u1aa0\u1a9e\3\2\2\2\u1aa0\u1aa1\3\2\2\2\u1aa1\u1aa3\3") + buf.write("\2\2\2\u1aa2\u1aa0\3\2\2\2\u1aa3\u1aa4\7\u024c\2\2\u1aa4") + buf.write("\u0297\3\2\2\2\u1aa5\u1aa6\7\u01a6\2\2\u1aa6\u1aa7\7\26") + buf.write("\2\2\u1aa7\u1aa8\5\u029a\u014e\2\u1aa8\u0299\3\2\2\2\u1aa9") + buf.write("\u1aae\5\u029c\u014f\2\u1aaa\u1aab\7\u0245\2\2\u1aab\u1aad") + buf.write("\5\u029c\u014f\2\u1aac\u1aaa\3\2\2\2\u1aad\u1ab0\3\2\2") + buf.write("\2\u1aae\u1aac\3\2\2\2\u1aae\u1aaf\3\2\2\2\u1aaf\u029b") + buf.write("\3\2\2\2\u1ab0\u1aae\3\2\2\2\u1ab1\u1ab3\5\u0230\u0119") + buf.write("\2\u1ab2\u1ab4\5\u026a\u0136\2\u1ab3\u1ab2\3\2\2\2\u1ab3") + buf.write("\u1ab4\3\2\2\2\u1ab4\u1ab6\3\2\2\2\u1ab5\u1ab7\5\u029e") + buf.write("\u0150\2\u1ab6\u1ab5\3\2\2\2\u1ab6\u1ab7\3\2\2\2\u1ab7") + buf.write("\u1ab9\3\2\2\2\u1ab8\u1aba\5\u02a0\u0151\2\u1ab9\u1ab8") + buf.write("\3\2\2\2\u1ab9\u1aba\3\2\2\2\u1aba\u029d\3\2\2\2\u1abb") + buf.write("\u1ac0\7\u0177\2\2\u1abc\u1ac0\7\u0189\2\2\u1abd\u1abe") + buf.write("\7\u01b7\2\2\u1abe\u1ac0\5\u0236\u011c\2\u1abf\u1abb\3") + buf.write("\2\2\2\u1abf\u1abc\3\2\2\2\u1abf\u1abd\3\2\2\2\u1ac0\u029f") + buf.write("\3\2\2\2\u1ac1\u1ac2\7\u009c\2\2\u1ac2\u1ac3\ta\2\2\u1ac3") + buf.write("\u02a1\3\2\2\2\u1ac4\u1ac6\5\u0276\u013c\2\u1ac5\u1ac4") + buf.write("\3\2\2\2\u1ac5\u1ac6\3\2\2\2\u1ac6\u1ac7\3\2\2\2\u1ac7") + buf.write("\u1ac8\7x\2\2\u1ac8\u1ac9\7\u019a\2\2\u1ac9\u1acc\5\u026a") + buf.write("\u0136\2\u1aca\u1acb\7\u0176\2\2\u1acb\u1acd\5\u0210\u0109") + buf.write("\2\u1acc\u1aca\3\2\2\2\u1acc\u1acd\3\2\2\2\u1acd\u1ad1") + buf.write("\3\2\2\2\u1ace\u1acf\7\u00a8\2\2\u1acf\u1ad0\tb\2\2\u1ad0") + buf.write("\u1ad2\7\u0117\2\2\u1ad1\u1ace\3\2\2\2\u1ad1\u1ad2\3\2") + buf.write("\2\2\u1ad2\u1ad4\3\2\2\2\u1ad3\u1ad5\5\u02a4\u0153\2\u1ad4") + buf.write("\u1ad3\3\2\2\2\u1ad4\u1ad5\3\2\2\2\u1ad5\u1ad9\3\2\2\2") + buf.write("\u1ad6\u1ada\5\u0270\u0139\2\u1ad7\u1ad8\7\u0187\2\2\u1ad8") + buf.write("\u1ada\7\u014c\2\2\u1ad9\u1ad6\3\2\2\2\u1ad9\u1ad7\3\2") + buf.write("\2\2\u1ada\u1ae1\3\2\2\2\u1adb\u1adc\7\u01a3\2\2\u1adc") + buf.write("\u1ade\7)\2\2\u1add\u1adf\5\u02a8\u0155\2\u1ade\u1add") + buf.write("\3\2\2\2\u1ade\u1adf\3\2\2\2\u1adf\u1ae0\3\2\2\2\u1ae0") + buf.write("\u1ae2\5\u02aa\u0156\2\u1ae1\u1adb\3\2\2\2\u1ae1\u1ae2") + buf.write("\3\2\2\2\u1ae2\u1ae5\3\2\2\2\u1ae3\u1ae4\7\u01aa\2\2\u1ae4") + buf.write("\u1ae6\5\u0280\u0141\2\u1ae5\u1ae3\3\2\2\2\u1ae5\u1ae6") + buf.write("\3\2\2\2\u1ae6\u02a3\3\2\2\2\u1ae7\u1ae8\7\u024b\2\2\u1ae8") + buf.write("\u1aed\5\u02a6\u0154\2\u1ae9\u1aea\7\u0245\2\2\u1aea\u1aec") + buf.write("\5\u02a6\u0154\2\u1aeb\u1ae9\3\2\2\2\u1aec\u1aef\3\2\2") + buf.write("\2\u1aed\u1aeb\3\2\2\2\u1aed\u1aee\3\2\2\2\u1aee\u1af0") + buf.write("\3\2\2\2\u1aef\u1aed\3\2\2\2\u1af0\u1af1\7\u024c\2\2\u1af1") + buf.write("\u02a5\3\2\2\2\u1af2\u1af4\5\u0210\u0109\2\u1af3\u1af5") + buf.write("\5\u0200\u0101\2\u1af4\u1af3\3\2\2\2\u1af4\u1af5\3\2\2") + buf.write("\2\u1af5\u02a7\3\2\2\2\u1af6\u1af8\5\u0094K\2\u1af7\u1af9") + buf.write("\5\u0098M\2\u1af8\u1af7\3\2\2\2\u1af8\u1af9\3\2\2\2\u1af9") + buf.write("\u1afe\3\2\2\2\u1afa\u1afb\7\u01a3\2\2\u1afb\u1afc\7\u017f") + buf.write("\2\2\u1afc\u1afe\5\u0210\u0109\2\u1afd\u1af6\3\2\2\2\u1afd") + buf.write("\u1afa\3\2\2\2\u1afe\u02a9\3\2\2\2\u1aff\u1b00\7\u018b") + buf.write("\2\2\u1b00\u1b11\7\u0099\2\2\u1b01\u1b02\7\u018b\2\2\u1b02") + buf.write("\u1b03\7\u0112\2\2\u1b03\u1b04\7\u00e6\2\2\u1b04\u1b09") + buf.write("\5\u02b0\u0159\2\u1b05\u1b06\7\u0245\2\2\u1b06\u1b08\5") + buf.write("\u02b0\u0159\2\u1b07\u1b05\3\2\2\2\u1b08\u1b0b\3\2\2\2") + buf.write("\u1b09\u1b07\3\2\2\2\u1b09\u1b0a\3\2\2\2\u1b0a\u1b0e\3") + buf.write("\2\2\2\u1b0b\u1b09\3\2\2\2\u1b0c\u1b0d\7\u01ba\2\2\u1b0d") + buf.write("\u1b0f\5\u0230\u0119\2\u1b0e\u1b0c\3\2\2\2\u1b0e\u1b0f") + buf.write("\3\2\2\2\u1b0f\u1b11\3\2\2\2\u1b10\u1aff\3\2\2\2\u1b10") + buf.write("\u1b01\3\2\2\2\u1b11\u02ab\3\2\2\2\u1b12\u1b14\5\u0276") + buf.write("\u013c\2\u1b13\u1b12\3\2\2\2\u1b13\u1b14\3\2\2\2\u1b14") + buf.write("\u1b15\3\2\2\2\u1b15\u1b16\7>\2\2\u1b16\u1b18\7\u0193") + buf.write("\2\2\u1b17\u1b19\7\u01a4\2\2\u1b18\u1b17\3\2\2\2\u1b18") + buf.write("\u1b19\3\2\2\2\u1b19\u1b1a\3\2\2\2\u1b1a\u1b1c\5\u026a") + buf.write("\u0136\2\u1b1b\u1b1d\7\u024f\2\2\u1b1c\u1b1b\3\2\2\2\u1b1c") + buf.write("\u1b1d\3\2\2\2\u1b1d\u1b22\3\2\2\2\u1b1e\u1b20\7\u0176") + buf.write("\2\2\u1b1f\u1b1e\3\2\2\2\u1b1f\u1b20\3\2\2\2\u1b20\u1b21") + buf.write("\3\2\2\2\u1b21\u1b23\5\u0210\u0109\2\u1b22\u1b1f\3\2\2") + buf.write("\2\u1b22\u1b23\3\2\2\2\u1b23\u1b2d\3\2\2\2\u1b24\u1b25") + buf.write("\7\u01b7\2\2\u1b25\u1b2a\5\u0286\u0144\2\u1b26\u1b27\7") + buf.write("\u0245\2\2\u1b27\u1b29\5\u0286\u0144\2\u1b28\u1b26\3\2") + buf.write("\2\2\u1b29\u1b2c\3\2\2\2\u1b2a\u1b28\3\2\2\2\u1b2a\u1b2b") + buf.write("\3\2\2\2\u1b2b\u1b2e\3\2\2\2\u1b2c\u1b2a\3\2\2\2\u1b2d") + buf.write("\u1b24\3\2\2\2\u1b2d\u1b2e\3\2\2\2\u1b2e\u1b36\3\2\2\2") + buf.write("\u1b2f\u1b34\7\u01ba\2\2\u1b30\u1b35\5\u0230\u0119\2\u1b31") + buf.write("\u1b32\7\63\2\2\u1b32\u1b33\7\u009e\2\2\u1b33\u1b35\5") + buf.write("\u0210\u0109\2\u1b34\u1b30\3\2\2\2\u1b34\u1b31\3\2\2\2") + buf.write("\u1b35\u1b37\3\2\2\2\u1b36\u1b2f\3\2\2\2\u1b36\u1b37\3") + buf.write("\2\2\2\u1b37\u1b3a\3\2\2\2\u1b38\u1b39\7\u01aa\2\2\u1b39") + buf.write("\u1b3b\5\u0280\u0141\2\u1b3a\u1b38\3\2\2\2\u1b3a\u1b3b") + buf.write("\3\2\2\2\u1b3b\u02ad\3\2\2\2\u1b3c\u1b3e\5\u0276\u013c") + buf.write("\2\u1b3d\u1b3c\3\2\2\2\u1b3d\u1b3e\3\2\2\2\u1b3e\u1b3f") + buf.write("\3\2\2\2\u1b3f\u1b41\7\u0112\2\2\u1b40\u1b42\7\u01a4\2") + buf.write("\2\u1b41\u1b40\3\2\2\2\u1b41\u1b42\3\2\2\2\u1b42\u1b43") + buf.write("\3\2\2\2\u1b43\u1b45\5\u026a\u0136\2\u1b44\u1b46\7\u024f") + buf.write("\2\2\u1b45\u1b44\3\2\2\2\u1b45\u1b46\3\2\2\2\u1b46\u1b4b") + buf.write("\3\2\2\2\u1b47\u1b49\7\u0176\2\2\u1b48\u1b47\3\2\2\2\u1b48") + buf.write("\u1b49\3\2\2\2\u1b49\u1b4a\3\2\2\2\u1b4a\u1b4c\5\u0210") + buf.write("\u0109\2\u1b4b\u1b48\3\2\2\2\u1b4b\u1b4c\3\2\2\2\u1b4c") + buf.write("\u1b4d\3\2\2\2\u1b4d\u1b4e\7\u00e6\2\2\u1b4e\u1b53\5\u02b0") + buf.write("\u0159\2\u1b4f\u1b50\7\u0245\2\2\u1b50\u1b52\5\u02b0\u0159") + buf.write("\2\u1b51\u1b4f\3\2\2\2\u1b52\u1b55\3\2\2\2\u1b53\u1b51") + buf.write("\3\2\2\2\u1b53\u1b54\3\2\2\2\u1b54\u1b5f\3\2\2\2\u1b55") + buf.write("\u1b53\3\2\2\2\u1b56\u1b57\7\u0193\2\2\u1b57\u1b5c\5\u0286") + buf.write("\u0144\2\u1b58\u1b59\7\u0245\2\2\u1b59\u1b5b\5\u0286\u0144") + buf.write("\2\u1b5a\u1b58\3\2\2\2\u1b5b\u1b5e\3\2\2\2\u1b5c\u1b5a") + buf.write("\3\2\2\2\u1b5c\u1b5d\3\2\2\2\u1b5d\u1b60\3\2\2\2\u1b5e") + buf.write("\u1b5c\3\2\2\2\u1b5f\u1b56\3\2\2\2\u1b5f\u1b60\3\2\2\2") + buf.write("\u1b60\u1b68\3\2\2\2\u1b61\u1b66\7\u01ba\2\2\u1b62\u1b67") + buf.write("\5\u0230\u0119\2\u1b63\u1b64\7\63\2\2\u1b64\u1b65\7\u009e") + buf.write("\2\2\u1b65\u1b67\5\u0210\u0109\2\u1b66\u1b62\3\2\2\2\u1b66") + buf.write("\u1b63\3\2\2\2\u1b67\u1b69\3\2\2\2\u1b68\u1b61\3\2\2\2") + buf.write("\u1b68\u1b69\3\2\2\2\u1b69\u1b6c\3\2\2\2\u1b6a\u1b6b\7") + buf.write("\u01aa\2\2\u1b6b\u1b6d\5\u0280\u0141\2\u1b6c\u1b6a\3\2") + buf.write("\2\2\u1b6c\u1b6d\3\2\2\2\u1b6d\u02af\3\2\2\2\u1b6e\u1b6f") + buf.write("\5\u02a6\u0154\2\u1b6f\u1b72\7\u0242\2\2\u1b70\u1b73\5") + buf.write("\u0230\u0119\2\u1b71\u1b73\7\u0187\2\2\u1b72\u1b70\3\2") + buf.write("\2\2\u1b72\u1b71\3\2\2\2\u1b73\u1b96\3\2\2\2\u1b74\u1b75") + buf.write("\7\u024b\2\2\u1b75\u1b7a\5\u02a6\u0154\2\u1b76\u1b77\7") + buf.write("\u0245\2\2\u1b77\u1b79\5\u02a6\u0154\2\u1b78\u1b76\3\2") + buf.write("\2\2\u1b79\u1b7c\3\2\2\2\u1b7a\u1b78\3\2\2\2\u1b7a\u1b7b") + buf.write("\3\2\2\2\u1b7b\u1b7d\3\2\2\2\u1b7c\u1b7a\3\2\2\2\u1b7d") + buf.write("\u1b7e\7\u024c\2\2\u1b7e\u1b80\7\u0242\2\2\u1b7f\u1b81") + buf.write("\7\u0144\2\2\u1b80\u1b7f\3\2\2\2\u1b80\u1b81\3\2\2\2\u1b81") + buf.write("\u1b93\3\2\2\2\u1b82\u1b85\7\u024b\2\2\u1b83\u1b86\5\u0230") + buf.write("\u0119\2\u1b84\u1b86\7\u0187\2\2\u1b85\u1b83\3\2\2\2\u1b85") + buf.write("\u1b84\3\2\2\2\u1b86\u1b8e\3\2\2\2\u1b87\u1b8a\7\u0245") + buf.write("\2\2\u1b88\u1b8b\5\u0230\u0119\2\u1b89\u1b8b\7\u0187\2") + buf.write("\2\u1b8a\u1b88\3\2\2\2\u1b8a\u1b89\3\2\2\2\u1b8b\u1b8d") + buf.write("\3\2\2\2\u1b8c\u1b87\3\2\2\2\u1b8d\u1b90\3\2\2\2\u1b8e") + buf.write("\u1b8c\3\2\2\2\u1b8e\u1b8f\3\2\2\2\u1b8f\u1b91\3\2\2\2") + buf.write("\u1b90\u1b8e\3\2\2\2\u1b91\u1b94\7\u024c\2\2\u1b92\u1b94") + buf.write("\5\u026e\u0138\2\u1b93\u1b82\3\2\2\2\u1b93\u1b92\3\2\2") + buf.write("\2\u1b94\u1b96\3\2\2\2\u1b95\u1b6e\3\2\2\2\u1b95\u1b74") + buf.write("\3\2\2\2\u1b96\u02b1\3\2\2\2\u1b97\u1b98\7\u009a\2\2\u1b98") + buf.write("\u1b9b\5\u0210\u0109\2\u1b99\u1b9a\7\u0245\2\2\u1b9a\u1b9c") + buf.write("\5\u0146\u00a4\2\u1b9b\u1b99\3\2\2\2\u1b9b\u1b9c\3\2\2") + buf.write("\2\u1b9c\u02b3\3\2\2\2\u1b9d\u1b9f\7\u0107\2\2\u1b9e\u1ba0") + buf.write("\7\u01af\2\2\u1b9f\u1b9e\3\2\2\2\u1b9f\u1ba0\3\2\2\2\u1ba0") + buf.write("\u1ba1\3\2\2\2\u1ba1\u1ba6\5\u0186\u00c4\2\u1ba2\u1ba3") + buf.write("\7\u0245\2\2\u1ba3\u1ba5\5\u0186\u00c4\2\u1ba4\u1ba2\3") + buf.write("\2\2\2\u1ba5\u1ba8\3\2\2\2\u1ba6\u1ba4\3\2\2\2\u1ba6\u1ba7") + buf.write("\3\2\2\2\u1ba7\u1bab\3\2\2\2\u1ba8\u1ba6\3\2\2\2\u1ba9") + buf.write("\u1baa\tc\2\2\u1baa\u1bac\7h\2\2\u1bab\u1ba9\3\2\2\2\u1bab") + buf.write("\u1bac\3\2\2\2\u1bac\u1bae\3\2\2\2\u1bad\u1baf\5\u01f8") + buf.write("\u00fd\2\u1bae\u1bad\3\2\2\2\u1bae\u1baf\3\2\2\2\u1baf") + buf.write("\u02b5\3\2\2\2\u1bb0\u1bb5\5\u0210\u0109\2\u1bb1\u1bb2") + buf.write("\7\u0245\2\2\u1bb2\u1bb4\5\u0210\u0109\2\u1bb3\u1bb1\3") + buf.write("\2\2\2\u1bb4\u1bb7\3\2\2\2\u1bb5\u1bb3\3\2\2\2\u1bb5\u1bb6") + buf.write("\3\2\2\2\u1bb6\u02b7\3\2\2\2\u1bb7\u1bb5\3\2\2\2\u1bb8") + buf.write("\u1bbe\7\u018b\2\2\u1bb9\u1bbc\7~\2\2\u1bba\u1bbd\5\u0210") + buf.write("\u0109\2\u1bbb\u1bbd\5\u0146\u00a4\2\u1bbc\u1bba\3\2\2") + buf.write("\2\u1bbc\u1bbb\3\2\2\2\u1bbd\u1bbf\3\2\2\2\u1bbe\u1bb9") + buf.write("\3\2\2\2\u1bbe\u1bbf\3\2\2\2\u1bbf\u1bc0\3\2\2\2\u1bc0") + buf.write("\u1bc9\5\u0146\u00a4\2\u1bc1\u1bc2\7\u018b\2\2\u1bc2\u1bc3") + buf.write("\5\u0146\u00a4\2\u1bc3\u1bc6\7~\2\2\u1bc4\u1bc7\5\u0210") + buf.write("\u0109\2\u1bc5\u1bc7\5\u0146\u00a4\2\u1bc6\u1bc4\3\2\2") + buf.write("\2\u1bc6\u1bc5\3\2\2\2\u1bc7\u1bc9\3\2\2\2\u1bc8\u1bb8") + buf.write("\3\2\2\2\u1bc8\u1bc1\3\2\2\2\u1bc9\u02b9\3\2\2\2\u1bca") + buf.write("\u1bcb\7\u025e\2\2\u1bcb\u1bce\5\u0210\u0109\2\u1bcc\u1bcf") + buf.write("\5\u0210\u0109\2\u1bcd\u1bcf\5\u0240\u0121\2\u1bce\u1bcc") + buf.write("\3\2\2\2\u1bce\u1bcd\3\2\2\2\u1bcf\u02bb\3\2\2\2\u1bd0") + buf.write("\u1bd2\5\u02be\u0160\2\u1bd1\u1bd0\3\2\2\2\u1bd1\u1bd2") + buf.write("\3\2\2\2\u1bd2\u1bd4\3\2\2\2\u1bd3\u1bd5\5\u02c0\u0161") + buf.write("\2\u1bd4\u1bd3\3\2\2\2\u1bd4\u1bd5\3\2\2\2\u1bd5\u1bd6") + buf.write("\3\2\2\2\u1bd6\u1bd7\7\25\2\2\u1bd7\u1bd9\5\u02cc\u0167") + buf.write("\2\u1bd8\u1bda\5\u02ca\u0166\2\u1bd9\u1bd8\3\2\2\2\u1bd9") + buf.write("\u1bda\3\2\2\2\u1bda\u1bdb\3\2\2\2\u1bdb\u1bdd\7\u018d") + buf.write("\2\2\u1bdc\u1bde\5\u0210\u0109\2\u1bdd\u1bdc\3\2\2\2\u1bdd") + buf.write("\u1bde\3\2\2\2\u1bde\u02bd\3\2\2\2\u1bdf\u1be0\7\u025b") + buf.write("\2\2\u1be0\u1be1\5\u0210\u0109\2\u1be1\u1be2\7\u025c\2") + buf.write("\2\u1be2\u02bf\3\2\2\2\u1be3\u1be7\7:\2\2\u1be4\u1be6") + buf.write("\5\u02c2\u0162\2\u1be5\u1be4\3\2\2\2\u1be6\u1be9\3\2\2") + buf.write("\2\u1be7\u1be5\3\2\2\2\u1be7\u1be8\3\2\2\2\u1be8\u02c1") + buf.write("\3\2\2\2\u1be9\u1be7\3\2\2\2\u1bea\u1bec\7:\2\2\u1beb") + buf.write("\u1bea\3\2\2\2\u1bec\u1bef\3\2\2\2\u1bed\u1beb\3\2\2\2") + buf.write("\u1bed\u1bee\3\2\2\2\u1bee\u1bf0\3\2\2\2\u1bef\u1bed\3") + buf.write("\2\2\2\u1bf0\u1bf1\5\u0210\u0109\2\u1bf1\u1bf2\5\u02c4") + buf.write("\u0163\2\u1bf2\u1bf3\7\u0244\2\2\u1bf3\u02c3\3\2\2\2\u1bf4") + buf.write("\u1bf6\7\u0222\2\2\u1bf5\u1bf4\3\2\2\2\u1bf5\u1bf6\3\2") + buf.write("\2\2\u1bf6\u1bf7\3\2\2\2\u1bf7\u1bf9\5\u02c8\u0165\2\u1bf8") + buf.write("\u1bfa\5\u01fa\u00fe\2\u1bf9\u1bf8\3\2\2\2\u1bf9\u1bfa") + buf.write("\3\2\2\2\u1bfa\u1bfd\3\2\2\2\u1bfb\u1bfc\7\u01a0\2\2\u1bfc") + buf.write("\u1bfe\7\u01a1\2\2\u1bfd\u1bfb\3\2\2\2\u1bfd\u1bfe\3\2") + buf.write("\2\2\u1bfe\u1c01\3\2\2\2\u1bff\u1c00\td\2\2\u1c00\u1c02") + buf.write("\5\u0230\u0119\2\u1c01\u1bff\3\2\2\2\u1c01\u1c02\3\2\2") + buf.write("\2\u1c02\u1c19\3\2\2\2\u1c03\u1c04\7\u0220\2\2\u1c04\u1c07") + buf.write("\7\u0191\2\2\u1c05\u1c08\5\u0210\u0109\2\u1c06\u1c08\7") + buf.write("\u0264\2\2\u1c07\u1c05\3\2\2\2\u1c07\u1c06\3\2\2\2\u1c08") + buf.write("\u1c19\3\2\2\2\u1c09\u1c0b\7\u0098\2\2\u1c0a\u1c09\3\2") + buf.write("\2\2\u1c0a\u1c0b\3\2\2\2\u1c0b\u1c0c\3\2\2\2\u1c0c\u1c0e") + buf.write("\7\u00dd\2\2\u1c0d\u1c0a\3\2\2\2\u1c0d\u1c0e\3\2\2\2\u1c0e") + buf.write("\u1c0f\3\2\2\2\u1c0f\u1c14\7\64\2\2\u1c10\u1c11\7\u024b") + buf.write("\2\2\u1c11\u1c12\5\u02c6\u0164\2\u1c12\u1c13\7\u024c\2") + buf.write("\2\u1c13\u1c15\3\2\2\2\u1c14\u1c10\3\2\2\2\u1c14\u1c15") + buf.write("\3\2\2\2\u1c15\u1c16\3\2\2\2\u1c16\u1c17\te\2\2\u1c17") + buf.write("\u1c19\5\u0270\u0139\2\u1c18\u1bf5\3\2\2\2\u1c18\u1c03") + buf.write("\3\2\2\2\u1c18\u1c0d\3\2\2\2\u1c19\u02c5\3\2\2\2\u1c1a") + buf.write("\u1c1b\5\u0210\u0109\2\u1c1b\u1c22\5\u0224\u0113\2\u1c1c") + buf.write("\u1c1d\7\u0245\2\2\u1c1d\u1c1e\5\u0210\u0109\2\u1c1e\u1c1f") + buf.write("\5\u0224\u0113\2\u1c1f\u1c21\3\2\2\2\u1c20\u1c1c\3\2\2") + buf.write("\2\u1c21\u1c24\3\2\2\2\u1c22\u1c20\3\2\2\2\u1c22\u1c23") + buf.write("\3\2\2\2\u1c23\u02c7\3\2\2\2\u1c24\u1c22\3\2\2\2\u1c25") + buf.write("\u1c2f\5\u0224\u0113\2\u1c26\u1c27\5\u026a\u0136\2\u1c27") + buf.write("\u1c28\7\u0251\2\2\u1c28\u1c29\7\u0109\2\2\u1c29\u1c2f") + buf.write("\3\2\2\2\u1c2a\u1c2b\5\u0220\u0111\2\u1c2b\u1c2c\7\u0251") + buf.write("\2\2\u1c2c\u1c2d\7\u023b\2\2\u1c2d\u1c2f\3\2\2\2\u1c2e") + buf.write("\u1c25\3\2\2\2\u1c2e\u1c26\3\2\2\2\u1c2e\u1c2a\3\2\2\2") + buf.write("\u1c2f\u02c9\3\2\2\2\u1c30\u1c36\7\u022b\2\2\u1c31\u1c32") + buf.write("\7\u01b9\2\2\u1c32\u1c33\5\u0230\u0119\2\u1c33\u1c34\7") + buf.write("\u01b0\2\2\u1c34\u1c35\5\u02cc\u0167\2\u1c35\u1c37\3\2") + buf.write("\2\2\u1c36\u1c31\3\2\2\2\u1c37\u1c38\3\2\2\2\u1c38\u1c36") + buf.write("\3\2\2\2\u1c38\u1c39\3\2\2\2\u1c39\u02cb\3\2\2\2\u1c3a") + buf.write("\u1c3b\5\u02ce\u0168\2\u1c3b\u1c3c\7\u0244\2\2\u1c3c\u1c3e") + buf.write("\3\2\2\2\u1c3d\u1c3a\3\2\2\2\u1c3e\u1c41\3\2\2\2\u1c3f") + buf.write("\u1c3d\3\2\2\2\u1c3f\u1c40\3\2\2\2\u1c40\u02cd\3\2\2\2") + buf.write("\u1c41\u1c3f\3\2\2\2\u1c42\u1c4c\5\u02bc\u015f\2\u1c43") + buf.write("\u1c4c\5\u02d0\u0169\2\u1c44\u1c4c\5\u02dc\u016f\2\u1c45") + buf.write("\u1c4c\5\u02e2\u0172\2\u1c46\u1c4c\5\u02de\u0170\2\u1c47") + buf.write("\u1c4c\5\u02e4\u0173\2\u1c48\u1c4c\5<\37\2\u1c49\u1c4c") + buf.write("\5\u02f8\u017d\2\u1c4a\u1c4c\5\36\20\2\u1c4b\u1c42\3\2") + buf.write("\2\2\u1c4b\u1c43\3\2\2\2\u1c4b\u1c44\3\2\2\2\u1c4b\u1c45") + buf.write("\3\2\2\2\u1c4b\u1c46\3\2\2\2\u1c4b\u1c47\3\2\2\2\u1c4b") + buf.write("\u1c48\3\2\2\2\u1c4b\u1c49\3\2\2\2\u1c4b\u1c4a\3\2\2\2") + buf.write("\u1c4c\u02cf\3\2\2\2\u1c4d\u1c5f\5\u02d8\u016d\2\u1c4e") + buf.write("\u1c4f\7\u0235\2\2\u1c4f\u1c5f\5\u02d6\u016c\2\u1c50\u1c52") + buf.write("\7\u022d\2\2\u1c51\u1c53\tf\2\2\u1c52\u1c51\3\2\2\2\u1c52") + buf.write("\u1c53\3\2\2\2\u1c53\u1c54\3\2\2\2\u1c54\u1c55\7\u0226") + buf.write("\2\2\u1c55\u1c5a\5\u02d4\u016b\2\u1c56\u1c57\7\u0245\2") + buf.write("\2\u1c57\u1c59\5\u02d4\u016b\2\u1c58\u1c56\3\2\2\2\u1c59") + buf.write("\u1c5c\3\2\2\2\u1c5a\u1c58\3\2\2\2\u1c5a\u1c5b\3\2\2\2") + buf.write("\u1c5b\u1c5f\3\2\2\2\u1c5c\u1c5a\3\2\2\2\u1c5d\u1c5f\7") + buf.write("\u01a1\2\2\u1c5e\u1c4d\3\2\2\2\u1c5e\u1c4e\3\2\2\2\u1c5e") + buf.write("\u1c50\3\2\2\2\u1c5e\u1c5d\3\2\2\2\u1c5f\u02d1\3\2\2\2") + buf.write("\u1c60\u1c63\5\u026a\u0136\2\u1c61\u1c63\7\u0264\2\2\u1c62") + buf.write("\u1c60\3\2\2\2\u1c62\u1c61\3\2\2\2\u1c63\u1c6a\3\2\2\2") + buf.write("\u1c64\u1c65\7\u0257\2\2\u1c65\u1c66\5\u0230\u0119\2\u1c66") + buf.write("\u1c67\7\u0258\2\2\u1c67\u1c69\3\2\2\2\u1c68\u1c64\3\2") + buf.write("\2\2\u1c69\u1c6c\3\2\2\2\u1c6a\u1c68\3\2\2\2\u1c6a\u1c6b") + buf.write("\3\2\2\2\u1c6b\u02d3\3\2\2\2\u1c6c\u1c6a\3\2\2\2\u1c6d") + buf.write("\u1c6e\5\u02d2\u016a\2\u1c6e\u1c6f\tg\2\2\u1c6f\u1c70") + buf.write("\5\u0210\u0109\2\u1c70\u02d5\3\2\2\2\u1c71\u1c7e\5\u026c") + buf.write("\u0137\2\u1c72\u1c73\7\u01a3\2\2\u1c73\u1c74\7\u024b\2") + buf.write("\2\u1c74\u1c79\5\u0230\u0119\2\u1c75\u1c76\7\u0245\2\2") + buf.write("\u1c76\u1c78\5\u0230\u0119\2\u1c77\u1c75\3\2\2\2\u1c78") + buf.write("\u1c7b\3\2\2\2\u1c79\u1c77\3\2\2\2\u1c79\u1c7a\3\2\2\2") + buf.write("\u1c7a\u1c7c\3\2\2\2\u1c7b\u1c79\3\2\2\2\u1c7c\u1c7d\7") + buf.write("\u024c\2\2\u1c7d\u1c7f\3\2\2\2\u1c7e\u1c72\3\2\2\2\u1c7e") + buf.write("\u1c7f\3\2\2\2\u1c7f\u1c81\3\2\2\2\u1c80\u1c71\3\2\2\2") + buf.write("\u1c80\u1c81\3\2\2\2\u1c81\u1c82\3\2\2\2\u1c82\u1c8c\5") + buf.write("\u0280\u0141\2\u1c83\u1c84\7\u0193\2\2\u1c84\u1c89\5\u0286") + buf.write("\u0144\2\u1c85\u1c86\7\u0245\2\2\u1c86\u1c88\5\u0286\u0144") + buf.write("\2\u1c87\u1c85\3\2\2\2\u1c88\u1c8b\3\2\2\2\u1c89\u1c87") + buf.write("\3\2\2\2\u1c89\u1c8a\3\2\2\2\u1c8a\u1c8d\3\2\2\2\u1c8b") + buf.write("\u1c89\3\2\2\2\u1c8c\u1c83\3\2\2\2\u1c8c\u1c8d\3\2\2\2") + buf.write("\u1c8d\u1c90\3\2\2\2\u1c8e\u1c8f\7\u01ba\2\2\u1c8f\u1c91") + buf.write("\5\u0230\u0119\2\u1c90\u1c8e\3\2\2\2\u1c90\u1c91\3\2\2") + buf.write("\2\u1c91\u1c93\3\2\2\2\u1c92\u1c94\5\u028e\u0148\2\u1c93") + buf.write("\u1c92\3\2\2\2\u1c93\u1c94\3\2\2\2\u1c94\u1c97\3\2\2\2") + buf.write("\u1c95\u1c96\7\u0196\2\2\u1c96\u1c98\5\u0230\u0119\2\u1c97") + buf.write("\u1c95\3\2\2\2\u1c97\u1c98\3\2\2\2\u1c98\u1ca7\3\2\2\2") + buf.write("\u1c99\u1c9a\7\u01bb\2\2\u1c9a\u1c9b\5\u0210\u0109\2\u1c9b") + buf.write("\u1c9c\7\u0176\2\2\u1c9c\u1ca4\5\u025e\u0130\2\u1c9d\u1c9e") + buf.write("\7\u0245\2\2\u1c9e\u1c9f\5\u0210\u0109\2\u1c9f\u1ca0\7") + buf.write("\u0176\2\2\u1ca0\u1ca1\5\u025e\u0130\2\u1ca1\u1ca3\3\2") + buf.write("\2\2\u1ca2\u1c9d\3\2\2\2\u1ca3\u1ca6\3\2\2\2\u1ca4\u1ca2") + buf.write("\3\2\2\2\u1ca4\u1ca5\3\2\2\2\u1ca5\u1ca8\3\2\2\2\u1ca6") + buf.write("\u1ca4\3\2\2\2\u1ca7\u1c99\3\2\2\2\u1ca7\u1ca8\3\2\2\2") + buf.write("\u1ca8\u1cae\3\2\2\2\u1ca9\u1cab\t^\2\2\u1caa\u1cac\5") + buf.write("\u026c\u0137\2\u1cab\u1caa\3\2\2\2\u1cab\u1cac\3\2\2\2") + buf.write("\u1cac\u1cad\3\2\2\2\u1cad\u1caf\5\u027a\u013e\2\u1cae") + buf.write("\u1ca9\3\2\2\2\u1cae\u1caf\3\2\2\2\u1caf\u1cb3\3\2\2\2") + buf.write("\u1cb0\u1cb2\5\u0272\u013a\2\u1cb1\u1cb0\3\2\2\2\u1cb2") + buf.write("\u1cb5\3\2\2\2\u1cb3\u1cb1\3\2\2\2\u1cb3\u1cb4\3\2\2\2") + buf.write("\u1cb4\u02d7\3\2\2\2\u1cb5\u1cb3\3\2\2\2\u1cb6\u1cb7\5") + buf.write("\u02d2\u016a\2\u1cb7\u1cba\tg\2\2\u1cb8\u1cbb\5\u0274") + buf.write("\u013b\2\u1cb9\u1cbb\5\u02d6\u016c\2\u1cba\u1cb8\3\2\2") + buf.write("\2\u1cba\u1cb9\3\2\2\2\u1cbb\u02d9\3\2\2\2\u1cbc\u1cbd") + buf.write("\7T\2\2\u1cbd\u1cbf\5\u0230\u0119\2\u1cbe\u1cc0\5\u02f2") + buf.write("\u017a\2\u1cbf\u1cbe\3\2\2\2\u1cbf\u1cc0\3\2\2\2\u1cc0") + buf.write("\u02db\3\2\2\2\u1cc1\u1cc8\5\u02ec\u0177\2\u1cc2\u1cc3") + buf.write("\7\30\2\2\u1cc3\u1cc8\5\u0246\u0124\2\u1cc4\u1cc8\5\u02f4") + buf.write("\u017b\2\u1cc5\u1cc8\5\u02f6\u017c\2\u1cc6\u1cc8\5\u02ee") + buf.write("\u0178\2\u1cc7\u1cc1\3\2\2\2\u1cc7\u1cc2\3\2\2\2\u1cc7") + buf.write("\u1cc4\3\2\2\2\u1cc7\u1cc5\3\2\2\2\u1cc7\u1cc6\3\2\2\2") + buf.write("\u1cc8\u02dd\3\2\2\2\u1cc9\u1cca\7\u0234\2\2\u1cca\u1ccf") + buf.write("\5\u02d2\u016a\2\u1ccb\u1ccd\7\u0098\2\2\u1ccc\u1ccb\3") + buf.write("\2\2\2\u1ccc\u1ccd\3\2\2\2\u1ccd\u1cce\3\2\2\2\u1cce\u1cd0") + buf.write("\7\u00dd\2\2\u1ccf\u1ccc\3\2\2\2\u1ccf\u1cd0\3\2\2\2\u1cd0") + buf.write("\u1cd1\3\2\2\2\u1cd1\u1cd2\7\u0191\2\2\u1cd2\u1cd3\5\u02f8") + buf.write("\u017d\2\u1cd3\u1cf6\3\2\2\2\u1cd4\u1cd5\7\u0234\2\2\u1cd5") + buf.write("\u1ce1\5\u02d2\u016a\2\u1cd6\u1cd7\7\u024b\2\2\u1cd7\u1cdc") + buf.write("\5\u02e0\u0171\2\u1cd8\u1cd9\7\u0245\2\2\u1cd9\u1cdb\5") + buf.write("\u02e0\u0171\2\u1cda\u1cd8\3\2\2\2\u1cdb\u1cde\3\2\2\2") + buf.write("\u1cdc\u1cda\3\2\2\2\u1cdc\u1cdd\3\2\2\2\u1cdd\u1cdf\3") + buf.write("\2\2\2\u1cde\u1cdc\3\2\2\2\u1cdf\u1ce0\7\u024c\2\2\u1ce0") + buf.write("\u1ce2\3\2\2\2\u1ce1\u1cd6\3\2\2\2\u1ce1\u1ce2\3\2\2\2") + buf.write("\u1ce2\u1cf6\3\2\2\2\u1ce3\u1ce5\7\u0190\2\2\u1ce4\u1ce6") + buf.write("\5:\36\2\u1ce5\u1ce4\3\2\2\2\u1ce5\u1ce6\3\2\2\2\u1ce6") + buf.write("\u1ce8\3\2\2\2\u1ce7\u1ce9\t\7\2\2\u1ce8\u1ce7\3\2\2\2") + buf.write("\u1ce8\u1ce9\3\2\2\2\u1ce9\u1cea\3\2\2\2\u1cea\u1cf6\5") + buf.write("\u02d2\u016a\2\u1ceb\u1ced\7\u0093\2\2\u1cec\u1cee\5:") + buf.write("\36\2\u1ced\u1cec\3\2\2\2\u1ced\u1cee\3\2\2\2\u1cee\u1cf0") + buf.write("\3\2\2\2\u1cef\u1cf1\t\7\2\2\u1cf0\u1cef\3\2\2\2\u1cf0") + buf.write("\u1cf1\3\2\2\2\u1cf1\u1cf2\3\2\2\2\u1cf2\u1cf6\5\u02d2") + buf.write("\u016a\2\u1cf3\u1cf4\7!\2\2\u1cf4\u1cf6\5\u02d2\u016a") + buf.write("\2\u1cf5\u1cc9\3\2\2\2\u1cf5\u1cd4\3\2\2\2\u1cf5\u1ce3") + buf.write("\3\2\2\2\u1cf5\u1ceb\3\2\2\2\u1cf5\u1cf3\3\2\2\2\u1cf6") + buf.write("\u02df\3\2\2\2\u1cf7\u1cf8\5\u0210\u0109\2\u1cf8\u1cf9") + buf.write("\7\u025a\2\2\u1cf9\u1cfb\3\2\2\2\u1cfa\u1cf7\3\2\2\2\u1cfa") + buf.write("\u1cfb\3\2\2\2\u1cfb\u1cfc\3\2\2\2\u1cfc\u1cfd\5\u0230") + buf.write("\u0119\2\u1cfd\u02e1\3\2\2\2\u1cfe\u1d04\th\2\2\u1cff") + buf.write("\u1d01\7\u0173\2\2\u1d00\u1d02\7\u0098\2\2\u1d01\u1d00") + buf.write("\3\2\2\2\u1d01\u1d02\3\2\2\2\u1d02\u1d03\3\2\2\2\u1d03") + buf.write("\u1d05\7\35\2\2\u1d04\u1cff\3\2\2\2\u1d04\u1d05\3\2\2") + buf.write("\2\u1d05\u1d08\3\2\2\2\u1d06\u1d08\5\30\r\2\u1d07\u1cfe") + buf.write("\3\2\2\2\u1d07\u1d06\3\2\2\2\u1d08\u02e3\3\2\2\2\u1d09") + buf.write("\u1d0b\7\u0237\2\2\u1d0a\u1d0c\5\u02e6\u0174\2\u1d0b\u1d0a") + buf.write("\3\2\2\2\u1d0b\u1d0c\3\2\2\2\u1d0c\u1d15\3\2\2\2\u1d0d") + buf.write("\u1d12\5\u0146\u00a4\2\u1d0e\u1d0f\7\u0245\2\2\u1d0f\u1d11") + buf.write("\5\u0230\u0119\2\u1d10\u1d0e\3\2\2\2\u1d11\u1d14\3\2\2") + buf.write("\2\u1d12\u1d10\3\2\2\2\u1d12\u1d13\3\2\2\2\u1d13\u1d16") + buf.write("\3\2\2\2\u1d14\u1d12\3\2\2\2\u1d15\u1d0d\3\2\2\2\u1d15") + buf.write("\u1d16\3\2\2\2\u1d16\u1d18\3\2\2\2\u1d17\u1d19\5\u02e8") + buf.write("\u0175\2\u1d18\u1d17\3\2\2\2\u1d18\u1d19\3\2\2\2\u1d19") + buf.write("\u1d32\3\2\2\2\u1d1a\u1d1c\7\u0237\2\2\u1d1b\u1d1d\5\u02e6") + buf.write("\u0174\2\u1d1c\u1d1b\3\2\2\2\u1d1c\u1d1d\3\2\2\2\u1d1d") + buf.write("\u1d1e\3\2\2\2\u1d1e\u1d20\5\u0210\u0109\2\u1d1f\u1d21") + buf.write("\5\u02e8\u0175\2\u1d20\u1d1f\3\2\2\2\u1d20\u1d21\3\2\2") + buf.write("\2\u1d21\u1d32\3\2\2\2\u1d22\u1d24\7\u0237\2\2\u1d23\u1d25") + buf.write("\5\u02e6\u0174\2\u1d24\u1d23\3\2\2\2\u1d24\u1d25\3\2\2") + buf.write("\2\u1d25\u1d26\3\2\2\2\u1d26\u1d27\7\u023d\2\2\u1d27\u1d29") + buf.write("\5\u0146\u00a4\2\u1d28\u1d2a\5\u02e8\u0175\2\u1d29\u1d28") + buf.write("\3\2\2\2\u1d29\u1d2a\3\2\2\2\u1d2a\u1d32\3\2\2\2\u1d2b") + buf.write("\u1d2c\7\u0221\2\2\u1d2c\u1d2f\5\u0230\u0119\2\u1d2d\u1d2e") + buf.write("\7\u0245\2\2\u1d2e\u1d30\5\u0230\u0119\2\u1d2f\u1d2d\3") + buf.write("\2\2\2\u1d2f\u1d30\3\2\2\2\u1d30\u1d32\3\2\2\2\u1d31\u1d09") + buf.write("\3\2\2\2\u1d31\u1d1a\3\2\2\2\u1d31\u1d22\3\2\2\2\u1d31") + buf.write("\u1d2b\3\2\2\2\u1d32\u02e5\3\2\2\2\u1d33\u1d34\ti\2\2") + buf.write("\u1d34\u02e7\3\2\2\2\u1d35\u1d36\7\u01b7\2\2\u1d36\u1d37") + buf.write("\5\u02ea\u0176\2\u1d37\u1d38\7\u0242\2\2\u1d38\u1d40\5") + buf.write("\u0230\u0119\2\u1d39\u1d3a\7\u0245\2\2\u1d3a\u1d3b\5\u02ea") + buf.write("\u0176\2\u1d3b\u1d3c\7\u0242\2\2\u1d3c\u1d3d\5\u0230\u0119") + buf.write("\2\u1d3d\u1d3f\3\2\2\2\u1d3e\u1d39\3\2\2\2\u1d3f\u1d42") + buf.write("\3\2\2\2\u1d40\u1d3e\3\2\2\2\u1d40\u1d41\3\2\2\2\u1d41") + buf.write("\u02e9\3\2\2\2\u1d42\u1d40\3\2\2\2\u1d43\u1d44\tj\2\2") + buf.write("\u1d44\u02eb\3\2\2\2\u1d45\u1d47\7\u0239\2\2\u1d46\u1d48") + buf.write("\5\u02d6\u016c\2\u1d47\u1d46\3\2\2\2\u1d47\u1d48\3\2\2") + buf.write("\2\u1d48\u1d50\3\2\2\2\u1d49\u1d4a\7\u0239\2\2\u1d4a\u1d4b") + buf.write("\7\u0097\2\2\u1d4b\u1d50\5\u0230\u0119\2\u1d4c\u1d4d\7") + buf.write("\u0239\2\2\u1d4d\u1d4e\7\u0236\2\2\u1d4e\u1d50\5\u02f8") + buf.write("\u017d\2\u1d4f\u1d45\3\2\2\2\u1d4f\u1d49\3\2\2\2\u1d4f") + buf.write("\u1d4c\3\2\2\2\u1d50\u02ed\3\2\2\2\u1d51\u1d53\5\u02be") + buf.write("\u0160\2\u1d52\u1d51\3\2\2\2\u1d52\u1d53\3\2\2\2\u1d53") + buf.write("\u1d55\3\2\2\2\u1d54\u1d56\5\u02f0\u0179\2\u1d55\u1d54") + buf.write("\3\2\2\2\u1d55\u1d56\3\2\2\2\u1d56\u1d57\3\2\2\2\u1d57") + buf.write("\u1d58\7\u0231\2\2\u1d58\u1d59\5\u02cc\u0167\2\u1d59\u1d5a") + buf.write("\7\u018d\2\2\u1d5a\u1d5c\7\u0231\2\2\u1d5b\u1d5d\5\u0210") + buf.write("\u0109\2\u1d5c\u1d5b\3\2\2\2\u1d5c\u1d5d\3\2\2\2\u1d5d") + buf.write("\u1d67\3\2\2\2\u1d5e\u1d60\tk\2\2\u1d5f\u1d61\5\u0210") + buf.write("\u0109\2\u1d60\u1d5f\3\2\2\2\u1d60\u1d61\3\2\2\2\u1d61") + buf.write("\u1d64\3\2\2\2\u1d62\u1d63\7\u01b9\2\2\u1d63\u1d65\5\u0230") + buf.write("\u0119\2\u1d64\u1d62\3\2\2\2\u1d64\u1d65\3\2\2\2\u1d65") + buf.write("\u1d67\3\2\2\2\u1d66\u1d52\3\2\2\2\u1d66\u1d5e\3\2\2\2") + buf.write("\u1d67\u02ef\3\2\2\2\u1d68\u1d69\7\u0240\2\2\u1d69\u1d98") + buf.write("\5\u0230\u0119\2\u1d6a\u1d6b\7\u0191\2\2\u1d6b\u1d6c\5") + buf.write("\u0210\u0109\2\u1d6c\u1d6e\7\u0197\2\2\u1d6d\u1d6f\7\u023a") + buf.write("\2\2\u1d6e\u1d6d\3\2\2\2\u1d6e\u1d6f\3\2\2\2\u1d6f\u1d70") + buf.write("\3\2\2\2\u1d70\u1d71\5\u0230\u0119\2\u1d71\u1d72\7\u025d") + buf.write("\2\2\u1d72\u1d75\5\u0230\u0119\2\u1d73\u1d74\7\26\2\2") + buf.write("\u1d74\u1d76\5\u0230\u0119\2\u1d75\u1d73\3\2\2\2\u1d75") + buf.write("\u1d76\3\2\2\2\u1d76\u1d98\3\2\2\2\u1d77\u1d78\7\u0191") + buf.write("\2\2\u1d78\u1d79\5\u02b6\u015c\2\u1d79\u1d7a\7\u0197\2") + buf.write("\2\u1d7a\u1d7b\5\u02f8\u017d\2\u1d7b\u1d98\3\2\2\2\u1d7c") + buf.write("\u1d7d\7\u0191\2\2\u1d7d\u1d7e\5\u0210\u0109\2\u1d7e\u1d7f") + buf.write("\7\u0197\2\2\u1d7f\u1d8b\5\u0210\u0109\2\u1d80\u1d81\7") + buf.write("\u024b\2\2\u1d81\u1d86\5\u02e0\u0171\2\u1d82\u1d83\7\u0245") + buf.write("\2\2\u1d83\u1d85\5\u02e0\u0171\2\u1d84\u1d82\3\2\2\2\u1d85") + buf.write("\u1d88\3\2\2\2\u1d86\u1d84\3\2\2\2\u1d86\u1d87\3\2\2\2") + buf.write("\u1d87\u1d89\3\2\2\2\u1d88\u1d86\3\2\2\2\u1d89\u1d8a\7") + buf.write("\u024c\2\2\u1d8a\u1d8c\3\2\2\2\u1d8b\u1d80\3\2\2\2\u1d8b") + buf.write("\u1d8c\3\2\2\2\u1d8c\u1d98\3\2\2\2\u1d8d\u1d8e\7\u022c") + buf.write("\2\2\u1d8e\u1d91\5\u02b6\u015c\2\u1d8f\u1d90\7\u023c\2") + buf.write("\2\u1d90\u1d92\7\u0262\2\2\u1d91\u1d8f\3\2\2\2\u1d91\u1d92") + buf.write("\3\2\2\2\u1d92\u1d93\3\2\2\2\u1d93\u1d94\7\u0197\2\2\u1d94") + buf.write("\u1d95\7\u0175\2\2\u1d95\u1d96\5\u0230\u0119\2\u1d96\u1d98") + buf.write("\3\2\2\2\u1d97\u1d68\3\2\2\2\u1d97\u1d6a\3\2\2\2\u1d97") + buf.write("\u1d77\3\2\2\2\u1d97\u1d7c\3\2\2\2\u1d97\u1d8d\3\2\2\2") + buf.write("\u1d98\u02f1\3\2\2\2\u1d99\u1d9a\7\u01b7\2\2\u1d9a\u1d9f") + buf.write("\5\u0230\u0119\2\u1d9b\u1d9c\7\u0245\2\2\u1d9c\u1d9e\5") + buf.write("\u0230\u0119\2\u1d9d\u1d9b\3\2\2\2\u1d9e\u1da1\3\2\2\2") + buf.write("\u1d9f\u1d9d\3\2\2\2\u1d9f\u1da0\3\2\2\2\u1da0\u02f3\3") + buf.write("\2\2\2\u1da1\u1d9f\3\2\2\2\u1da2\u1da3\7i\2\2\u1da3\u1da4") + buf.write("\5\u0230\u0119\2\u1da4\u1da5\7\u01b0\2\2\u1da5\u1dad\5") + buf.write("\u02cc\u0167\2\u1da6\u1da7\tl\2\2\u1da7\u1da8\5\u0230") + buf.write("\u0119\2\u1da8\u1da9\7\u01b0\2\2\u1da9\u1daa\5\u02cc\u0167") + buf.write("\2\u1daa\u1dac\3\2\2\2\u1dab\u1da6\3\2\2\2\u1dac\u1daf") + buf.write("\3\2\2\2\u1dad\u1dab\3\2\2\2\u1dad\u1dae\3\2\2\2\u1dae") + buf.write("\u1db2\3\2\2\2\u1daf\u1dad\3\2\2\2\u1db0\u1db1\7\u018c") + buf.write("\2\2\u1db1\u1db3\5\u02cc\u0167\2\u1db2\u1db0\3\2\2\2\u1db2") + buf.write("\u1db3\3\2\2\2\u1db3\u1db4\3\2\2\2\u1db4\u1db5\7\u018d") + buf.write("\2\2\u1db5\u1db6\7i\2\2\u1db6\u02f5\3\2\2\2\u1db7\u1db9") + buf.write("\7\u017a\2\2\u1db8\u1dba\5\u0230\u0119\2\u1db9\u1db8\3") + buf.write("\2\2\2\u1db9\u1dba\3\2\2\2\u1dba\u1dc7\3\2\2\2\u1dbb\u1dbc") + buf.write("\7\u01b9\2\2\u1dbc\u1dc1\5\u0230\u0119\2\u1dbd\u1dbe\7") + buf.write("\u0245\2\2\u1dbe\u1dc0\5\u0230\u0119\2\u1dbf\u1dbd\3\2") + buf.write("\2\2\u1dc0\u1dc3\3\2\2\2\u1dc1\u1dbf\3\2\2\2\u1dc1\u1dc2") + buf.write("\3\2\2\2\u1dc2\u1dc4\3\2\2\2\u1dc3\u1dc1\3\2\2\2\u1dc4") + buf.write("\u1dc5\7\u01b0\2\2\u1dc5\u1dc6\5\u02cc\u0167\2\u1dc6\u1dc8") + buf.write("\3\2\2\2\u1dc7\u1dbb\3\2\2\2\u1dc8\u1dc9\3\2\2\2\u1dc9") + buf.write("\u1dc7\3\2\2\2\u1dc9\u1dca\3\2\2\2\u1dca\u1dcd\3\2\2\2") + buf.write("\u1dcb\u1dcc\7\u018c\2\2\u1dcc\u1dce\5\u02cc\u0167\2\u1dcd") + buf.write("\u1dcb\3\2\2\2\u1dcd\u1dce\3\2\2\2\u1dce\u1dcf\3\2\2\2") + buf.write("\u1dcf\u1dd0\7\u018d\2\2\u1dd0\u1dd1\7\u017a\2\2\u1dd1") + buf.write("\u02f7\3\2\2\2\u1dd2\u1dd7\5\20\t\2\u1dd3\u1dd7\5\u02da") + buf.write("\u016e\2\u1dd4\u1dd7\5(\25\2\u1dd5\u1dd7\5 \21\2\u1dd6") + buf.write("\u1dd2\3\2\2\2\u1dd6\u1dd3\3\2\2\2\u1dd6\u1dd4\3\2\2\2") + buf.write("\u1dd6\u1dd5\3\2\2\2\u1dd7\u02f9\3\2\2\2\u040f\u02fb\u0300") + buf.write("\u0307\u030a\u030e\u0317\u0321\u0327\u032b\u0330\u0337") + buf.write("\u033f\u0345\u0349\u034f\u0351\u0358\u035b\u035f\u0363") + buf.write("\u0366\u036c\u0372\u0374\u037c\u0380\u0384\u038f\u0396") + buf.write("\u0399\u039d\u03a4\u03ab\u03ae\u03b9\u03bc\u03c2\u03c6") + buf.write("\u03c9\u03cf\u03d9\u03e1\u03ea\u03f0\u03f3\u03f7\u0400") + buf.write("\u0402\u0409\u040d\u0413\u0417\u041e\u0426\u042c\u0431") + buf.write("\u0434\u043e\u0443\u0450\u0459\u045d\u0460\u0468\u046d") + buf.write("\u0477\u0479\u0483\u0488\u048d\u0490\u0493\u0496\u049b") + buf.write("\u04a4\u04af\u04b3\u04b7\u04bc\u04c3\u04cd\u04d2\u04da") + buf.write("\u04e0\u04e3\u04e6\u04e9\u04eb\u04ef\u04f3\u04fc\u0502") + buf.write("\u0506\u0508\u050d\u0536\u053d\u0560\u056e\u0577\u057d") + buf.write("\u0585\u0589\u0590\u0594\u0596\u0598\u059b\u05a3\u05a9") + buf.write("\u05b4\u05b6\u05ba\u05db\u05ee\u0616\u061d\u0623\u0626") + buf.write("\u062a\u062d\u0631\u0638\u063d\u0653\u0657\u065a\u065f") + buf.write("\u0662\u0666\u066a\u0673\u067c\u068e\u06b8\u06be\u06c1") + buf.write("\u06c3\u06c7\u06cc\u06d0\u06d8\u06df\u06ef\u06f1\u06f7") + buf.write("\u06ff\u0703\u070a\u0710\u0713\u0715\u0720\u0724\u0727") + buf.write("\u0731\u073c\u0744\u0748\u0758\u075f\u0766\u076b\u076f") + buf.write("\u077c\u0782\u0784\u0790\u0793\u07a8\u07ad\u07b4\u07b9") + buf.write("\u07c0\u07c2\u07c9\u07d4\u07d9\u07db\u07e2\u07e4\u07ec") + buf.write("\u07ee\u07f5\u07f7\u07fb\u07ff\u0807\u080d\u0810\u0812") + buf.write("\u0814\u0819\u081c\u0820\u0825\u082a\u0832\u083c\u0840") + buf.write("\u0849\u084e\u0856\u0863\u0866\u0873\u087f\u0887\u088e") + buf.write("\u0896\u08a0\u08ac\u08b3\u08be\u08c2\u08c9\u08cc\u08d1") + buf.write("\u08d5\u08dc\u08e1\u08e4\u08e6\u08f0\u08f4\u08f7\u08fa") + buf.write("\u08fe\u0905\u0909\u090c\u090f\u0912\u091f\u0929\u092d") + buf.write("\u0931\u0936\u0938\u093d\u093f\u0942\u0946\u0949\u094c") + buf.write("\u0954\u0958\u095a\u096a\u096f\u0973\u0975\u0984\u0987") + buf.write("\u0991\u0994\u09a8\u09ba\u09be\u09c2\u09c9\u09cc\u09e9") + buf.write("\u0a07\u0a0b\u0a10\u0a15\u0a1c\u0a1e\u0a23\u0a28\u0a2c") + buf.write("\u0a33\u0a41\u0a55\u0a63\u0a6c\u0a86\u0a8f\u0a95\u0aa0") + buf.write("\u0aa3\u0aa6\u0aaf\u0ab5\u0aba\u0abf\u0ac4\u0ac9\u0ad0") + buf.write("\u0ad5\u0ade\u0ae3\u0ae5\u0ae9\u0aee\u0af6\u0b00\u0b0a") + buf.write("\u0b0f\u0b1c\u0b36\u0b39\u0b3c\u0b3f\u0b4c\u0b56\u0b5d") + buf.write("\u0b69\u0b6f\u0b72\u0b76\u0b84\u0b89\u0b92\u0b97\u0ba3") + buf.write("\u0ba7\u0bab\u0bb2\u0bb6\u0bbc\u0bc1\u0bc7\u0bcf\u0bd2") + buf.write("\u0bd6\u0bf6\u0bfc\u0bff\u0c04\u0c08\u0c15\u0c1a\u0c1f") + buf.write("\u0c28\u0c33\u0c36\u0c3b\u0c40\u0c42\u0c46\u0c4c\u0c57") + buf.write("\u0c5c\u0c60\u0c67\u0c78\u0c7e\u0c87\u0c8c\u0c99\u0ca1") + buf.write("\u0cb6\u0cba\u0cbf\u0cc7\u0cd4\u0d0c\u0d14\u0d1d\u0d2c") + buf.write("\u0d30\u0d36\u0d3d\u0d45\u0d4a\u0d53\u0d55\u0d5c\u0d60") + buf.write("\u0d64\u0d6f\u0d73\u0d7d\u0d82\u0d86\u0d8d\u0d90\u0d98") + buf.write("\u0d9d\u0da2\u0da4\u0da7\u0dab\u0db1\u0db4\u0db7\u0dbc") + buf.write("\u0dbe\u0dc2\u0dc5\u0dc8\u0dd1\u0ddd\u0ddf\u0de3\u0ded") + buf.write("\u0df0\u0df3\u0e09\u0e13\u0e23\u0e2a\u0e37\u0e3c\u0e4a") + buf.write("\u0e53\u0e59\u0e5f\u0e61\u0e68\u0e6d\u0e74\u0e78\u0e82") + buf.write("\u0e89\u0e8b\u0e92\u0eaa\u0ebe\u0ec8\u0eda\u0f10\u0f20") + buf.write("\u0f28\u0f2d\u0f3f\u0f43\u0f4a\u0f4c\u0f53\u0f56\u0f63") + buf.write("\u0f74\u0f77\u0f7a\u0f7d\u0f88\u0f8f\u0f94\u0f97\u0f9a") + buf.write("\u0f9f\u0fa4\u0fa8\u0fae\u0fb8\u0fbf\u0fc5\u0fc9\u0fcf") + buf.write("\u0fd5\u0fd8\u0fdd\u0fe5\u0fe8\u0fec\u0ff4\u0ff8\u1000") + buf.write("\u1003\u1007\u100c\u101e\u1021\u1025\u102a\u102c\u1030") + buf.write("\u1036\u103f\u104b\u1050\u1058\u1069\u106f\u1073\u107b") + buf.write("\u1093\u109c\u109f\u10aa\u10b1\u10b6\u10b8\u10bb\u10bf") + buf.write("\u10c6\u10cb\u10cd\u10d4\u10da\u10e0\u10e9\u10f1\u10fa") + buf.write("\u10ff\u1102\u110a\u1111\u1116\u1118\u111b\u1121\u112b") + buf.write("\u1130\u1136\u1139\u1149\u1154\u115a\u115d\u116e\u1171") + buf.write("\u1174\u1178\u1183\u118d\u1193\u1197\u119a\u11a1\u11a3") + buf.write("\u11a7\u11af\u11b3\u11b7\u11ba\u11c1\u11c3\u11c7\u11cc") + buf.write("\u11d0\u11d5\u11d9\u11dd\u11e2\u11e7\u11f1\u11f9\u120b") + buf.write("\u120f\u1212\u1215\u1218\u121c\u1220\u1224\u1228\u122b") + buf.write("\u1230\u1234\u1237\u1246\u124d\u1253\u1257\u125b\u1260") + buf.write("\u1264\u1267\u126a\u126d\u1270\u1274\u1278\u127c\u1280") + buf.write("\u1283\u1286\u1289\u128f\u1293\u1296\u129b\u12a0\u12a7") + buf.write("\u12ad\u12b5\u12be\u12d0\u12d8\u12e3\u12e6\u12eb\u12f0") + buf.write("\u12fd\u1304\u1309\u1312\u1318\u131c\u1320\u1328\u1334") + buf.write("\u1337\u133c\u1341\u1345\u134a\u134d\u1352\u135a\u135e") + buf.write("\u1361\u1366\u1373\u137a\u137f\u1384\u138b\u138d\u1396") + buf.write("\u1399\u139f\u13a2\u13b0\u13bf\u13ce\u13d3\u13d6\u13dc") + buf.write("\u13de\u13e9\u13f2\u13fa\u13ff\u1409\u1412\u141c\u1423") + buf.write("\u1436\u1438\u1443\u144d\u1450\u1457\u145c\u1461\u146b") + buf.write("\u146f\u1472\u1476\u147a\u147d\u1481\u1487\u148b\u1491") + buf.write("\u149e\u14a6\u14a9\u14ad\u14bd\u14c2\u14c6\u14cb\u14d0") + buf.write("\u14d5\u14dc\u14ed\u14f4\u14f8\u14fd\u1502\u1504\u1508") + buf.write("\u150f\u1512\u1517\u151b\u1521\u1527\u152a\u152d\u1531") + buf.write("\u1534\u1538\u153b\u153f\u1545\u154a\u154e\u1553\u1557") + buf.write("\u1560\u1565\u1567\u1584\u158e\u1597\u159f\u15ab\u15c1") + buf.write("\u15c5\u15cd\u15d3\u15d8\u15de\u15ea\u15fe\u1608\u160b") + buf.write("\u1612\u1616\u161b\u1621\u1627\u1632\u1634\u163c\u1644") + buf.write("\u164e\u1663\u1670\u1676\u167c\u1683\u1685\u1690\u169a") + buf.write("\u16ad\u16ba\u16bf\u16c7\u16d0\u16d4\u16e2\u16e9\u16ed") + buf.write("\u16ef\u16f8\u16fb\u1700\u1702\u170a\u170d\u1712\u171f") + buf.write("\u172b\u172e\u1731\u1737\u1743\u1748\u174c\u1750\u1754") + buf.write("\u1756\u175b\u1762\u1767\u1769\u1774\u1779\u177d\u1791") + buf.write("\u179b\u17a7\u17ad\u17b1\u17b6\u17bc\u17c6\u17cc\u17d0") + buf.write("\u17db\u17e7\u17ef\u17f1\u17fb\u1800\u1820\u1826\u182c") + buf.write("\u1831\u1839\u183e\u1844\u1848\u184b\u184e\u1852\u1858") + buf.write("\u1864\u1867\u186a\u186d\u1878\u1881\u1883\u188a\u188f") + buf.write("\u1894\u1899\u189d\u18a0\u18ab\u18ad\u18b4\u18b6\u18bf") + buf.write("\u18c5\u18cc\u18d1\u18d6\u18da\u18e4\u18ec\u18ef\u18f4") + buf.write("\u18f6\u18f9\u18ff\u1904\u190b\u1915\u191a\u191e\u1921") + buf.write("\u192d\u1932\u1937\u193d\u1944\u1947\u1952\u1957\u1959") + buf.write("\u195c\u195f\u1967\u196a\u196e\u1971\u1975\u1982\u1985") + buf.write("\u1989\u198d\u1990\u1997\u199e\u19a2\u19a5\u19ae\u19b1") + buf.write("\u19bc\u19be\u19c6\u19c8\u19d3\u19d5\u19dc\u19de\u19e2") + buf.write("\u19e6\u19e9\u19f3\u19f9\u19fb\u19fe\u1a04\u1a09\u1a0e") + buf.write("\u1a17\u1a1d\u1a1f\u1a22\u1a2a\u1a30\u1a34\u1a3a\u1a3d") + buf.write("\u1a46\u1a4b\u1a4d\u1a4f\u1a52\u1a5b\u1a60\u1a6b\u1a79") + buf.write("\u1a83\u1a89\u1a91\u1a97\u1a9c\u1aa0\u1aae\u1ab3\u1ab6") + buf.write("\u1ab9\u1abf\u1ac5\u1acc\u1ad1\u1ad4\u1ad9\u1ade\u1ae1") + buf.write("\u1ae5\u1aed\u1af4\u1af8\u1afd\u1b09\u1b0e\u1b10\u1b13") + buf.write("\u1b18\u1b1c\u1b1f\u1b22\u1b2a\u1b2d\u1b34\u1b36\u1b3a") + buf.write("\u1b3d\u1b41\u1b45\u1b48\u1b4b\u1b53\u1b5c\u1b5f\u1b66") + buf.write("\u1b68\u1b6c\u1b72\u1b7a\u1b80\u1b85\u1b8a\u1b8e\u1b93") + buf.write("\u1b95\u1b9b\u1b9f\u1ba6\u1bab\u1bae\u1bb5\u1bbc\u1bbe") + buf.write("\u1bc6\u1bc8\u1bce\u1bd1\u1bd4\u1bd9\u1bdd\u1be7\u1bed") + buf.write("\u1bf5\u1bf9\u1bfd\u1c01\u1c07\u1c0a\u1c0d\u1c14\u1c18") + buf.write("\u1c22\u1c2e\u1c38\u1c3f\u1c4b\u1c52\u1c5a\u1c5e\u1c62") + buf.write("\u1c6a\u1c79\u1c7e\u1c80\u1c89\u1c8c\u1c90\u1c93\u1c97") + buf.write("\u1ca4\u1ca7\u1cab\u1cae\u1cb3\u1cba\u1cbf\u1cc7\u1ccc") + buf.write("\u1ccf\u1cdc\u1ce1\u1ce5\u1ce8\u1ced\u1cf0\u1cf5\u1cfa") + buf.write("\u1d01\u1d04\u1d07\u1d0b\u1d12\u1d15\u1d18\u1d1c\u1d20") + buf.write("\u1d24\u1d29\u1d2f\u1d31\u1d40\u1d47\u1d4f\u1d52\u1d55") + buf.write("\u1d5c\u1d60\u1d64\u1d66\u1d6e\u1d75\u1d86\u1d8b\u1d91") + buf.write("\u1d97\u1d9f\u1dad\u1db2\u1db9\u1dc1\u1dc9\u1dcd\u1dd6") + return buf.getvalue() + + +class PLpgSQLParser ( Parser ): + + grammarFileName = "PLpgSQLParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "'='", "':'", "';'", "','", "", "'<'", "'<='", + "'>'", "'>='", "'('", "')'", "'+'", "'-'", "'*'", "'/'", + "'%'", "'^'", "'.'", "'''", "'\"'", "'$'", "'['", "']'", + "'=>'", "':='", "'<<'", "'>>'", "'..'", "'#'", "", + "", "", "", "", + "", "", "", "", + "", "' '", "", "", "'\u0009'", + "'\uFEFF'" ] + + symbolicNames = [ "", "ABORT", "ABSOLUTE", "ACCESS", "ACTION", + "ADD", "ADMIN", "AFTER", "AGGREGATE", "ALSO", "ALTER", + "ALWAYS", "ASSERTION", "ASSIGNMENT", "AT", "ATTACH", + "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN", "BY", + "CACHE", "CALL", "CALLED", "CASCADE", "CASCADED", + "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", + "CLASS", "CLOSE", "CLUSTER", "COLUMNS", "COMMENT", + "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION", + "CONFLICT", "CONNECTION", "CONSTRAINTS", "CONTENT", + "CONTINUE", "CONVERSION", "COPY", "COST", "CSV", "CUBE", + "CURRENT", "CURSOR", "CYCLE", "DATA", "DATABASE", + "DAY", "DEALLOCATE", "DECLARE", "DEFAULTS", "DEFERRED", + "DEFINER", "DELETE", "DELIMITER", "DELIMITERS", "DEPENDS", + "DETACH", "DICTIONARY", "DISABLE", "DISCARD", "DOCUMENT", + "DOMAIN", "DOUBLE", "DROP", "EACH", "ENABLE", "ENCODING", + "ENCRYPTED", "ENUM", "ESCAPE", "EVENT", "EXCLUDE", + "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXTENSION", + "EXTERNAL", "FAMILY", "FILTER", "FIRST", "FOLLOWING", + "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GENERATED", + "GLOBAL", "GRANTED", "GROUPS", "HANDLER", "HEADER", + "HOLD", "HOUR", "IDENTITY", "IF", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT", "IMPORT", "INCLUDE", "INCLUDING", "INCREMENT", + "INDEX", "INDEXES", "INHERIT", "INHERITS", "INLINE", + "INPUT", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", + "ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE", + "LAST", "LEAKPROOF", "LEVEL", "LISTEN", "LOAD", "LOCAL", + "LOCATION", "LOCK", "LOCKED", "LOGGED", "MAPPING", + "MATCH", "MATERIALIZED", "MAXVALUE", "METHOD", "MINUTE", + "MINVALUE", "MODE", "MONTH", "MOVE", "NAME", "NAMES", + "NEW", "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", + "NULLS", "OBJECT", "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", "RELEASE", + "RENAME", "REPEATABLE", "REPLACE", "REPLICA", "RESET", + "RESTART", "RESTRICT", "RETURNS", "REVOKE", "ROLE", + "ROLLBACK", "ROLLUP", "ROUTINE", "ROUTINES", "ROWS", + "RULE", "SAVEPOINT", "SCHEMA", "SCHEMAS", "SCROLL", + "SEARCH", "SECOND", "SECURITY", "SEQUENCE", "SEQUENCES", + "SERIALIZABLE", "SERVER", "SESSION", "SET", "SETS", + "SHARE", "SHOW", "SIMPLE", "SKIP_", "SNAPSHOT", "SQL", + "STABLE", "STANDALONE", "START", "STATEMENT", "STATISTICS", + "STDIN", "STDOUT", "STORAGE", "STORED", "STRICT", + "STRIP", "SUBSCRIPTION", "SUPPORT", "SYSID", "SYSTEM", + "TABLES", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", + "TEXT", "TIES", "TRANSACTION", "TRANSFORM", "TRIGGER", + "TRUNCATE", "TRUSTED", "TYPE", "TYPES", "UNBOUNDED", + "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", "UNLISTEN", + "UNLOGGED", "UNTIL", "UPDATE", "VACUUM", "VALID", + "VALIDATE", "VALIDATOR", "VALUE", "VARYING", "VERSION", + "VIEW", "VIEWS", "VOLATILE", "WHITESPACE", "WITHIN", + "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML", "YEAR", + "YES", "ZONE", "BETWEEN", "BIGINT", "BIT", "BOOLEAN", + "CHAR", "CHARACTER", "COALESCE", "DEC", "DECIMAL", + "EXISTS", "EXTRACT", "FLOAT", "GREATEST", "GROUPING", + "INOUT", "INT", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", "OUT", "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", + "AUTHORIZATION", "BINARY", "COLLATION", "CONCURRENTLY", + "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", "ILIKE", + "INNER", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", + "NOTNULL", "OUTER", "OVERLAPS", "RIGHT", "SIMILAR", + "TABLESAMPLE", "VERBOSE", "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", "EXCEPT", "FALSE", "FETCH", "FOR", + "FOREIGN", "FROM", "GRANT", "GROUP", "HAVING", "IN", + "INITIALLY", "INTERSECT", "INTO", "LATERAL", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL", + "OFFSET", "ON", "ONLY", "OR", "ORDER", "PLACING", + "PRIMARY", "REFERENCES", "RETURNING", "SELECT", "SESSION_USER", + "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", "TRAILING", + "TRUE", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", + "WHEN", "WHERE", "WINDOW", "WITH", "ALIGNMENT", "BASETYPE", + "BUFFERS", "BYPASSRLS", "CANONICAL", "CATEGORY", "COLLATABLE", + "COMBINEFUNC", "COMMUTATOR", "CONNECT", "COSTS", "CREATEDB", + "CREATEROLE", "DESERIALFUNC", "DETERMINISTIC", "DISABLE_PAGE_SKIPPING", + "ELEMENT", "EXTENDED", "FINALFUNC", "FINALFUNC_EXTRA", + "FINALFUNC_MODIFY", "FORCE_NOT_NULL", "FORCE_NULL", + "FORCE_QUOTE", "FORMAT", "GETTOKEN", "HASH", "HASHES", + "HEADLINE", "HYPOTHETICAL", "INDEX_CLEANUP", "INIT", + "INITCOND", "INTERNALLENGTH", "JSON", "LC_COLLATE", + "LC_CTYPE", "LEFTARG", "LEXIZE", "LEXTYPES", "LIST", + "LOCALE", "LOGIN", "MAIN", "MERGES", "MFINALFUNC", + "MFINALFUNC_EXTRA", "MFINALFUNC_MODIFY", "MINITCOND", + "MINVFUNC", "MODULUS", "MSFUNC", "MSSPACE", "MSTYPE", + "NEGATOR", "NOBYPASSRLS", "NOCREATEDB", "NOCREATEROLE", + "NOINHERIT", "NOLOGIN", "NOREPLICATION", "NOSUPERUSER", + "OUTPUT", "PASSEDBYVALUE", "PATH", "PERMISSIVE", "PLAIN", + "PREFERRED", "PROVIDER", "READ_ONLY", "READ_WRITE", + "RECEIVE", "REMAINDER", "REPLICATION", "RESTRICTED", + "RESTRICTIVE", "RIGHTARG", "SAFE", "SEND", "SERIALFUNC", + "SETTINGS", "SFUNC", "SHAREABLE", "SKIP_LOCKED", "SORTOP", + "SSPACE", "STYPE", "SUBTYPE_DIFF", "SUBTYPE_OPCLASS", + "SUBTYPE", "SUMMARY", "SUPERUSER", "TIMING", "TYPMOD_IN", + "TYPMOD_OUT", "UNSAFE", "USAGE", "VARIABLE", "YAML", + "ALIAS", "ASSERT", "CONSTANT", "DATATYPE", "DEBUG", + "DETAIL", "DIAGNOSTICS", "ELSEIF", "ELSIF", "ERRCODE", + "EXIT", "EXCEPTION", "FOREACH", "GET", "HINT", "INFO", + "LOG", "LOOP", "MESSAGE", "NOTICE", "OPEN", "PERFORM", + "QUERY", "RAISE", "RECORD", "RETURN", "REVERSE", "ROWTYPE", + "SLICE", "SQLSTATE", "STACKED", "WARNING", "WHILE", + "CAST_EXPRESSION", "EQUAL", "COLON", "SEMI_COLON", + "COMMA", "NOT_EQUAL", "LTH", "LEQ", "GTH", "GEQ", + "LEFT_PAREN", "RIGHT_PAREN", "PLUS", "MINUS", "MULTIPLY", + "DIVIDE", "MODULAR", "EXP", "DOT", "QUOTE_CHAR", "DOUBLE_QUOTE", + "DOLLAR", "LEFT_BRACKET", "RIGHT_BRACKET", "EQUAL_GTH", + "COLON_EQUAL", "LESS_LESS", "GREATER_GREATER", "DOUBLE_DOT", + "HASH_SIGN", "BlockComment", "LineComment", "OP_CHARS", + "NUMBER_LITERAL", "REAL_NUMBER", "DOLLAR_NUMBER", + "Identifier", "QuotedIdentifier", "Character_String_Literal", + "BeginDollarStringConstant", "Space", "White_Space", + "New_Line", "Tab", "BOM", "BAD", "Text_between_Dollar", + "EndDollarStringConstant" ] + + RULE_sql = 0 + RULE_qname_parser = 1 + RULE_function_args_parser = 2 + RULE_vex_eof = 3 + RULE_plpgsql_function = 4 + RULE_plpgsql_function_test_list = 5 + RULE_statement = 6 + RULE_data_statement = 7 + RULE_script_statement = 8 + RULE_script_transaction = 9 + RULE_transaction_mode = 10 + RULE_lock_table = 11 + RULE_lock_mode = 12 + RULE_script_additional = 13 + RULE_additional_statement = 14 + RULE_explain_statement = 15 + RULE_explain_query = 16 + RULE_execute_statement = 17 + RULE_declare_statement = 18 + RULE_show_statement = 19 + RULE_explain_option = 20 + RULE_user_name = 21 + RULE_table_cols_list = 22 + RULE_table_cols = 23 + RULE_vacuum_mode = 24 + RULE_vacuum_option = 25 + RULE_analyze_mode = 26 + RULE_boolean_value = 27 + RULE_fetch_move_direction = 28 + RULE_schema_statement = 29 + RULE_schema_create = 30 + RULE_schema_alter = 31 + RULE_schema_drop = 32 + RULE_schema_import = 33 + RULE_alter_function_statement = 34 + RULE_alter_aggregate_statement = 35 + RULE_alter_extension_statement = 36 + RULE_alter_extension_action = 37 + RULE_extension_member_object = 38 + RULE_alter_schema_statement = 39 + RULE_alter_language_statement = 40 + RULE_alter_table_statement = 41 + RULE_table_action = 42 + RULE_column_action = 43 + RULE_identity_body = 44 + RULE_alter_identity = 45 + RULE_storage_option = 46 + RULE_validate_constraint = 47 + RULE_drop_constraint = 48 + RULE_table_deferrable = 49 + RULE_table_initialy_immed = 50 + RULE_function_actions_common = 51 + RULE_function_def = 52 + RULE_alter_index_statement = 53 + RULE_index_def_action = 54 + RULE_alter_default_privileges = 55 + RULE_abbreviated_grant_or_revoke = 56 + RULE_grant_option_for = 57 + RULE_alter_sequence_statement = 58 + RULE_alter_view_statement = 59 + RULE_alter_event_trigger = 60 + RULE_alter_event_trigger_action = 61 + RULE_alter_type_statement = 62 + RULE_alter_domain_statement = 63 + RULE_alter_server_statement = 64 + RULE_alter_server_action = 65 + RULE_alter_fts_statement = 66 + RULE_alter_fts_configuration = 67 + RULE_type_action = 68 + RULE_set_def_column = 69 + RULE_drop_def = 70 + RULE_create_index_statement = 71 + RULE_index_rest = 72 + RULE_index_sort = 73 + RULE_including_index = 74 + RULE_index_where = 75 + RULE_create_extension_statement = 76 + RULE_create_language_statement = 77 + RULE_create_event_trigger = 78 + RULE_create_type_statement = 79 + RULE_create_domain_statement = 80 + RULE_create_server_statement = 81 + RULE_create_fts_dictionary = 82 + RULE_option_with_value = 83 + RULE_create_fts_configuration = 84 + RULE_create_fts_template = 85 + RULE_create_fts_parser = 86 + RULE_create_collation = 87 + RULE_alter_collation = 88 + RULE_collation_option = 89 + RULE_create_user_mapping = 90 + RULE_alter_user_mapping = 91 + RULE_alter_user_or_role = 92 + RULE_alter_user_or_role_set_reset = 93 + RULE_user_or_role_set_reset = 94 + RULE_alter_group = 95 + RULE_alter_group_action = 96 + RULE_alter_tablespace = 97 + RULE_alter_owner = 98 + RULE_alter_tablespace_action = 99 + RULE_alter_statistics = 100 + RULE_alter_foreign_data_wrapper = 101 + RULE_alter_foreign_data_wrapper_action = 102 + RULE_alter_operator_statement = 103 + RULE_alter_operator_action = 104 + RULE_operator_set_restrict_join = 105 + RULE_drop_user_mapping = 106 + RULE_drop_owned = 107 + RULE_drop_operator_statement = 108 + RULE_target_operator = 109 + RULE_domain_constraint = 110 + RULE_create_transform_statement = 111 + RULE_create_access_method = 112 + RULE_create_user_or_role = 113 + RULE_user_or_role_option = 114 + RULE_user_or_role_option_for_alter = 115 + RULE_user_or_role_or_group_common_option = 116 + RULE_user_or_role_common_option = 117 + RULE_user_or_role_or_group_option_for_create = 118 + RULE_create_group = 119 + RULE_group_option = 120 + RULE_create_tablespace = 121 + RULE_create_statistics = 122 + RULE_create_foreign_data_wrapper = 123 + RULE_option_without_equal = 124 + RULE_create_operator_statement = 125 + RULE_operator_name = 126 + RULE_operator_option = 127 + RULE_create_aggregate_statement = 128 + RULE_aggregate_param = 129 + RULE_set_statement = 130 + RULE_set_action = 131 + RULE_session_local_option = 132 + RULE_set_statement_value = 133 + RULE_create_rewrite_statement = 134 + RULE_rewrite_command = 135 + RULE_create_trigger_statement = 136 + RULE_trigger_referencing = 137 + RULE_when_trigger = 138 + RULE_rule_common = 139 + RULE_rule_member_object = 140 + RULE_columns_permissions = 141 + RULE_table_column_privileges = 142 + RULE_permissions = 143 + RULE_permission = 144 + RULE_other_rules = 145 + RULE_grant_to_rule = 146 + RULE_revoke_from_cascade_restrict = 147 + RULE_roles_names = 148 + RULE_role_name_with_group = 149 + RULE_comment_on_statement = 150 + RULE_security_label = 151 + RULE_comment_member_object = 152 + RULE_label_member_object = 153 + RULE_create_function_statement = 154 + RULE_create_funct_params = 155 + RULE_transform_for_type = 156 + RULE_function_ret_table = 157 + RULE_function_column_name_type = 158 + RULE_function_parameters = 159 + RULE_function_args = 160 + RULE_agg_order = 161 + RULE_character_string = 162 + RULE_function_arguments = 163 + RULE_argmode = 164 + RULE_create_sequence_statement = 165 + RULE_sequence_body = 166 + RULE_signed_number_literal = 167 + RULE_signed_numerical_literal = 168 + RULE_sign = 169 + RULE_create_schema_statement = 170 + RULE_create_policy_statement = 171 + RULE_alter_policy_statement = 172 + RULE_drop_policy_statement = 173 + RULE_create_subscription_statement = 174 + RULE_alter_subscription_statement = 175 + RULE_alter_subscription_action = 176 + RULE_create_cast_statement = 177 + RULE_drop_cast_statement = 178 + RULE_create_operator_family_statement = 179 + RULE_alter_operator_family_statement = 180 + RULE_operator_family_action = 181 + RULE_add_operator_to_family = 182 + RULE_drop_operator_from_family = 183 + RULE_drop_operator_family_statement = 184 + RULE_create_operator_class_statement = 185 + RULE_create_operator_class_option = 186 + RULE_alter_operator_class_statement = 187 + RULE_drop_operator_class_statement = 188 + RULE_create_conversion_statement = 189 + RULE_alter_conversion_statement = 190 + RULE_create_publication_statement = 191 + RULE_alter_publication_statement = 192 + RULE_alter_publication_action = 193 + RULE_only_table_multiply = 194 + RULE_alter_trigger_statement = 195 + RULE_alter_rule_statement = 196 + RULE_copy_statement = 197 + RULE_copy_from_statement = 198 + RULE_copy_to_statement = 199 + RULE_copy_option_list = 200 + RULE_copy_option = 201 + RULE_create_view_statement = 202 + RULE_if_exists = 203 + RULE_if_not_exists = 204 + RULE_view_columns = 205 + RULE_with_check_option = 206 + RULE_create_table_statement = 207 + RULE_create_table_as_statement = 208 + RULE_create_foreign_table_statement = 209 + RULE_define_table = 210 + RULE_define_partition = 211 + RULE_for_values_bound = 212 + RULE_partition_bound_spec = 213 + RULE_partition_bound_part = 214 + RULE_define_columns = 215 + RULE_define_type = 216 + RULE_partition_by = 217 + RULE_partition_method = 218 + RULE_partition_column = 219 + RULE_define_server = 220 + RULE_define_foreign_options = 221 + RULE_foreign_option = 222 + RULE_foreign_option_name = 223 + RULE_list_of_type_column_def = 224 + RULE_table_column_def = 225 + RULE_table_of_type_column_def = 226 + RULE_table_column_definition = 227 + RULE_like_option = 228 + RULE_constraint_common = 229 + RULE_constr_body = 230 + RULE_all_op = 231 + RULE_all_simple_op = 232 + RULE_op_chars = 233 + RULE_index_parameters = 234 + RULE_names_in_parens = 235 + RULE_names_references = 236 + RULE_storage_parameter = 237 + RULE_storage_parameter_option = 238 + RULE_storage_parameter_name = 239 + RULE_with_storage_parameter = 240 + RULE_storage_parameter_oid = 241 + RULE_on_commit = 242 + RULE_table_space = 243 + RULE_action = 244 + RULE_owner_to = 245 + RULE_rename_to = 246 + RULE_set_schema = 247 + RULE_table_column_privilege = 248 + RULE_usage_select_update = 249 + RULE_partition_by_columns = 250 + RULE_cascade_restrict = 251 + RULE_collate_identifier = 252 + RULE_indirection_var = 253 + RULE_dollar_number = 254 + RULE_indirection_list = 255 + RULE_indirection = 256 + RULE_drop_function_statement = 257 + RULE_drop_trigger_statement = 258 + RULE_drop_rule_statement = 259 + RULE_drop_statements = 260 + RULE_if_exist_names_restrict_cascade = 261 + RULE_id_token = 262 + RULE_identifier = 263 + RULE_identifier_nontype = 264 + RULE_col_label = 265 + RULE_tokens_nonreserved = 266 + RULE_tokens_nonreserved_except_function_type = 267 + RULE_tokens_reserved_except_function_type = 268 + RULE_tokens_reserved = 269 + RULE_tokens_nonkeyword = 270 + RULE_schema_qualified_name_nontype = 271 + RULE_type_list = 272 + RULE_data_type = 273 + RULE_array_type = 274 + RULE_predefined_type = 275 + RULE_interval_field = 276 + RULE_type_length = 277 + RULE_precision_param = 278 + RULE_vex = 279 + RULE_vex_b = 280 + RULE_op = 281 + RULE_all_op_ref = 282 + RULE_datetime_overlaps = 283 + RULE_value_expression_primary = 284 + RULE_unsigned_value_specification = 285 + RULE_unsigned_numeric_literal = 286 + RULE_truth_value = 287 + RULE_case_expression = 288 + RULE_cast_specification = 289 + RULE_function_call = 290 + RULE_vex_or_named_notation = 291 + RULE_pointer = 292 + RULE_function_construct = 293 + RULE_extract_function = 294 + RULE_system_function = 295 + RULE_date_time_function = 296 + RULE_string_value_function = 297 + RULE_xml_function = 298 + RULE_xml_table_column = 299 + RULE_comparison_mod = 300 + RULE_filter_clause = 301 + RULE_window_definition = 302 + RULE_frame_clause = 303 + RULE_frame_bound = 304 + RULE_array_expression = 305 + RULE_array_elements = 306 + RULE_type_coercion = 307 + RULE_schema_qualified_name = 308 + RULE_set_qualifier = 309 + RULE_table_subquery = 310 + RULE_select_stmt = 311 + RULE_after_ops = 312 + RULE_select_stmt_no_parens = 313 + RULE_with_clause = 314 + RULE_with_query = 315 + RULE_select_ops = 316 + RULE_select_ops_no_parens = 317 + RULE_select_primary = 318 + RULE_select_list = 319 + RULE_select_sublist = 320 + RULE_into_table = 321 + RULE_from_item = 322 + RULE_from_primary = 323 + RULE_alias_clause = 324 + RULE_from_function_column_def = 325 + RULE_groupby_clause = 326 + RULE_grouping_element_list = 327 + RULE_grouping_element = 328 + RULE_values_stmt = 329 + RULE_values_values = 330 + RULE_orderby_clause = 331 + RULE_sort_specifier_list = 332 + RULE_sort_specifier = 333 + RULE_order_specification = 334 + RULE_null_ordering = 335 + RULE_insert_stmt_for_psql = 336 + RULE_insert_columns = 337 + RULE_indirection_identifier = 338 + RULE_conflict_object = 339 + RULE_conflict_action = 340 + RULE_delete_stmt_for_psql = 341 + RULE_update_stmt_for_psql = 342 + RULE_update_set = 343 + RULE_notify_stmt = 344 + RULE_truncate_stmt = 345 + RULE_identifier_list = 346 + RULE_anonymous_block = 347 + RULE_comp_options = 348 + RULE_function_block = 349 + RULE_start_label = 350 + RULE_declarations = 351 + RULE_declaration = 352 + RULE_type_declaration = 353 + RULE_arguments_list = 354 + RULE_data_type_dec = 355 + RULE_exception_statement = 356 + RULE_function_statements = 357 + RULE_function_statement = 358 + RULE_base_statement = 359 + RULE_var = 360 + RULE_diagnostic_option = 361 + RULE_perform_stmt = 362 + RULE_assign_stmt = 363 + RULE_execute_stmt = 364 + RULE_control_statement = 365 + RULE_cursor_statement = 366 + RULE_option = 367 + RULE_transaction_statement = 368 + RULE_message_statement = 369 + RULE_log_level = 370 + RULE_raise_using = 371 + RULE_raise_param = 372 + RULE_return_stmt = 373 + RULE_loop_statement = 374 + RULE_loop_start = 375 + RULE_using_vex = 376 + RULE_if_statement = 377 + RULE_case_statement = 378 + RULE_plpgsql_query = 379 + + ruleNames = [ "sql", "qname_parser", "function_args_parser", "vex_eof", + "plpgsql_function", "plpgsql_function_test_list", "statement", + "data_statement", "script_statement", "script_transaction", + "transaction_mode", "lock_table", "lock_mode", "script_additional", + "additional_statement", "explain_statement", "explain_query", + "execute_statement", "declare_statement", "show_statement", + "explain_option", "user_name", "table_cols_list", "table_cols", + "vacuum_mode", "vacuum_option", "analyze_mode", "boolean_value", + "fetch_move_direction", "schema_statement", "schema_create", + "schema_alter", "schema_drop", "schema_import", "alter_function_statement", + "alter_aggregate_statement", "alter_extension_statement", + "alter_extension_action", "extension_member_object", + "alter_schema_statement", "alter_language_statement", + "alter_table_statement", "table_action", "column_action", + "identity_body", "alter_identity", "storage_option", + "validate_constraint", "drop_constraint", "table_deferrable", + "table_initialy_immed", "function_actions_common", "function_def", + "alter_index_statement", "index_def_action", "alter_default_privileges", + "abbreviated_grant_or_revoke", "grant_option_for", "alter_sequence_statement", + "alter_view_statement", "alter_event_trigger", "alter_event_trigger_action", + "alter_type_statement", "alter_domain_statement", "alter_server_statement", + "alter_server_action", "alter_fts_statement", "alter_fts_configuration", + "type_action", "set_def_column", "drop_def", "create_index_statement", + "index_rest", "index_sort", "including_index", "index_where", + "create_extension_statement", "create_language_statement", + "create_event_trigger", "create_type_statement", "create_domain_statement", + "create_server_statement", "create_fts_dictionary", "option_with_value", + "create_fts_configuration", "create_fts_template", "create_fts_parser", + "create_collation", "alter_collation", "collation_option", + "create_user_mapping", "alter_user_mapping", "alter_user_or_role", + "alter_user_or_role_set_reset", "user_or_role_set_reset", + "alter_group", "alter_group_action", "alter_tablespace", + "alter_owner", "alter_tablespace_action", "alter_statistics", + "alter_foreign_data_wrapper", "alter_foreign_data_wrapper_action", + "alter_operator_statement", "alter_operator_action", + "operator_set_restrict_join", "drop_user_mapping", "drop_owned", + "drop_operator_statement", "target_operator", "domain_constraint", + "create_transform_statement", "create_access_method", + "create_user_or_role", "user_or_role_option", "user_or_role_option_for_alter", + "user_or_role_or_group_common_option", "user_or_role_common_option", + "user_or_role_or_group_option_for_create", "create_group", + "group_option", "create_tablespace", "create_statistics", + "create_foreign_data_wrapper", "option_without_equal", + "create_operator_statement", "operator_name", "operator_option", + "create_aggregate_statement", "aggregate_param", "set_statement", + "set_action", "session_local_option", "set_statement_value", + "create_rewrite_statement", "rewrite_command", "create_trigger_statement", + "trigger_referencing", "when_trigger", "rule_common", + "rule_member_object", "columns_permissions", "table_column_privileges", + "permissions", "permission", "other_rules", "grant_to_rule", + "revoke_from_cascade_restrict", "roles_names", "role_name_with_group", + "comment_on_statement", "security_label", "comment_member_object", + "label_member_object", "create_function_statement", "create_funct_params", + "transform_for_type", "function_ret_table", "function_column_name_type", + "function_parameters", "function_args", "agg_order", + "character_string", "function_arguments", "argmode", + "create_sequence_statement", "sequence_body", "signed_number_literal", + "signed_numerical_literal", "sign", "create_schema_statement", + "create_policy_statement", "alter_policy_statement", + "drop_policy_statement", "create_subscription_statement", + "alter_subscription_statement", "alter_subscription_action", + "create_cast_statement", "drop_cast_statement", "create_operator_family_statement", + "alter_operator_family_statement", "operator_family_action", + "add_operator_to_family", "drop_operator_from_family", + "drop_operator_family_statement", "create_operator_class_statement", + "create_operator_class_option", "alter_operator_class_statement", + "drop_operator_class_statement", "create_conversion_statement", + "alter_conversion_statement", "create_publication_statement", + "alter_publication_statement", "alter_publication_action", + "only_table_multiply", "alter_trigger_statement", "alter_rule_statement", + "copy_statement", "copy_from_statement", "copy_to_statement", + "copy_option_list", "copy_option", "create_view_statement", + "if_exists", "if_not_exists", "view_columns", "with_check_option", + "create_table_statement", "create_table_as_statement", + "create_foreign_table_statement", "define_table", "define_partition", + "for_values_bound", "partition_bound_spec", "partition_bound_part", + "define_columns", "define_type", "partition_by", "partition_method", + "partition_column", "define_server", "define_foreign_options", + "foreign_option", "foreign_option_name", "list_of_type_column_def", + "table_column_def", "table_of_type_column_def", "table_column_definition", + "like_option", "constraint_common", "constr_body", "all_op", + "all_simple_op", "op_chars", "index_parameters", "names_in_parens", + "names_references", "storage_parameter", "storage_parameter_option", + "storage_parameter_name", "with_storage_parameter", "storage_parameter_oid", + "on_commit", "table_space", "action", "owner_to", "rename_to", + "set_schema", "table_column_privilege", "usage_select_update", + "partition_by_columns", "cascade_restrict", "collate_identifier", + "indirection_var", "dollar_number", "indirection_list", + "indirection", "drop_function_statement", "drop_trigger_statement", + "drop_rule_statement", "drop_statements", "if_exist_names_restrict_cascade", + "id_token", "identifier", "identifier_nontype", "col_label", + "tokens_nonreserved", "tokens_nonreserved_except_function_type", + "tokens_reserved_except_function_type", "tokens_reserved", + "tokens_nonkeyword", "schema_qualified_name_nontype", + "type_list", "data_type", "array_type", "predefined_type", + "interval_field", "type_length", "precision_param", "vex", + "vex_b", "op", "all_op_ref", "datetime_overlaps", "value_expression_primary", + "unsigned_value_specification", "unsigned_numeric_literal", + "truth_value", "case_expression", "cast_specification", + "function_call", "vex_or_named_notation", "pointer", + "function_construct", "extract_function", "system_function", + "date_time_function", "string_value_function", "xml_function", + "xml_table_column", "comparison_mod", "filter_clause", + "window_definition", "frame_clause", "frame_bound", "array_expression", + "array_elements", "type_coercion", "schema_qualified_name", + "set_qualifier", "table_subquery", "select_stmt", "after_ops", + "select_stmt_no_parens", "with_clause", "with_query", + "select_ops", "select_ops_no_parens", "select_primary", + "select_list", "select_sublist", "into_table", "from_item", + "from_primary", "alias_clause", "from_function_column_def", + "groupby_clause", "grouping_element_list", "grouping_element", + "values_stmt", "values_values", "orderby_clause", "sort_specifier_list", + "sort_specifier", "order_specification", "null_ordering", + "insert_stmt_for_psql", "insert_columns", "indirection_identifier", + "conflict_object", "conflict_action", "delete_stmt_for_psql", + "update_stmt_for_psql", "update_set", "notify_stmt", + "truncate_stmt", "identifier_list", "anonymous_block", + "comp_options", "function_block", "start_label", "declarations", + "declaration", "type_declaration", "arguments_list", + "data_type_dec", "exception_statement", "function_statements", + "function_statement", "base_statement", "var", "diagnostic_option", + "perform_stmt", "assign_stmt", "execute_stmt", "control_statement", + "cursor_statement", "option", "transaction_statement", + "message_statement", "log_level", "raise_using", "raise_param", + "return_stmt", "loop_statement", "loop_start", "using_vex", + "if_statement", "case_statement", "plpgsql_query" ] + + EOF = Token.EOF + ABORT=1 + ABSOLUTE=2 + ACCESS=3 + ACTION=4 + ADD=5 + ADMIN=6 + AFTER=7 + AGGREGATE=8 + ALSO=9 + ALTER=10 + ALWAYS=11 + ASSERTION=12 + ASSIGNMENT=13 + AT=14 + ATTACH=15 + ATTRIBUTE=16 + BACKWARD=17 + BEFORE=18 + BEGIN=19 + BY=20 + CACHE=21 + CALL=22 + CALLED=23 + CASCADE=24 + CASCADED=25 + CATALOG=26 + CHAIN=27 + CHARACTERISTICS=28 + CHECKPOINT=29 + CLASS=30 + CLOSE=31 + CLUSTER=32 + COLUMNS=33 + COMMENT=34 + COMMENTS=35 + COMMIT=36 + COMMITTED=37 + CONFIGURATION=38 + CONFLICT=39 + CONNECTION=40 + CONSTRAINTS=41 + CONTENT=42 + CONTINUE=43 + CONVERSION=44 + COPY=45 + COST=46 + CSV=47 + CUBE=48 + CURRENT=49 + CURSOR=50 + CYCLE=51 + DATA=52 + DATABASE=53 + DAY=54 + DEALLOCATE=55 + DECLARE=56 + DEFAULTS=57 + DEFERRED=58 + DEFINER=59 + DELETE=60 + DELIMITER=61 + DELIMITERS=62 + DEPENDS=63 + DETACH=64 + DICTIONARY=65 + DISABLE=66 + DISCARD=67 + DOCUMENT=68 + DOMAIN=69 + DOUBLE=70 + DROP=71 + EACH=72 + ENABLE=73 + ENCODING=74 + ENCRYPTED=75 + ENUM=76 + ESCAPE=77 + EVENT=78 + EXCLUDE=79 + EXCLUDING=80 + EXCLUSIVE=81 + EXECUTE=82 + EXPLAIN=83 + EXTENSION=84 + EXTERNAL=85 + FAMILY=86 + FILTER=87 + FIRST=88 + FOLLOWING=89 + FORCE=90 + FORWARD=91 + FUNCTION=92 + FUNCTIONS=93 + GENERATED=94 + GLOBAL=95 + GRANTED=96 + GROUPS=97 + HANDLER=98 + HEADER=99 + HOLD=100 + HOUR=101 + IDENTITY=102 + IF=103 + IMMEDIATE=104 + IMMUTABLE=105 + IMPLICIT=106 + IMPORT=107 + INCLUDE=108 + INCLUDING=109 + INCREMENT=110 + INDEX=111 + INDEXES=112 + INHERIT=113 + INHERITS=114 + INLINE=115 + INPUT=116 + INSENSITIVE=117 + INSERT=118 + INSTEAD=119 + INVOKER=120 + ISOLATION=121 + KEY=122 + LABEL=123 + LANGUAGE=124 + LARGE=125 + LAST=126 + LEAKPROOF=127 + LEVEL=128 + LISTEN=129 + LOAD=130 + LOCAL=131 + LOCATION=132 + LOCK=133 + LOCKED=134 + LOGGED=135 + MAPPING=136 + MATCH=137 + MATERIALIZED=138 + MAXVALUE=139 + METHOD=140 + MINUTE=141 + MINVALUE=142 + MODE=143 + MONTH=144 + MOVE=145 + NAME=146 + NAMES=147 + NEW=148 + NEXT=149 + NO=150 + NOTHING=151 + NOTIFY=152 + NOWAIT=153 + NULLS=154 + OBJECT=155 + OF=156 + OFF=157 + OIDS=158 + OLD=159 + OPERATOR=160 + OPTION=161 + OPTIONS=162 + ORDINALITY=163 + OTHERS=164 + OVER=165 + OVERRIDING=166 + OWNED=167 + OWNER=168 + PARALLEL=169 + PARSER=170 + PARTIAL=171 + PARTITION=172 + PASSING=173 + PASSWORD=174 + PLANS=175 + POLICY=176 + PRECEDING=177 + PREPARE=178 + PREPARED=179 + PRESERVE=180 + PRIOR=181 + PRIVILEGES=182 + PROCEDURAL=183 + PROCEDURE=184 + PROCEDURES=185 + PROGRAM=186 + PUBLICATION=187 + QUOTE=188 + RANGE=189 + READ=190 + REASSIGN=191 + RECHECK=192 + RECURSIVE=193 + REF=194 + REFERENCING=195 + REFRESH=196 + REINDEX=197 + RELATIVE=198 + RELEASE=199 + RENAME=200 + REPEATABLE=201 + REPLACE=202 + REPLICA=203 + RESET=204 + RESTART=205 + RESTRICT=206 + RETURNS=207 + REVOKE=208 + ROLE=209 + ROLLBACK=210 + ROLLUP=211 + ROUTINE=212 + ROUTINES=213 + ROWS=214 + RULE=215 + SAVEPOINT=216 + SCHEMA=217 + SCHEMAS=218 + SCROLL=219 + SEARCH=220 + SECOND=221 + SECURITY=222 + SEQUENCE=223 + SEQUENCES=224 + SERIALIZABLE=225 + SERVER=226 + SESSION=227 + SET=228 + SETS=229 + SHARE=230 + SHOW=231 + SIMPLE=232 + SKIP_=233 + SNAPSHOT=234 + SQL=235 + STABLE=236 + STANDALONE=237 + START=238 + STATEMENT=239 + STATISTICS=240 + STDIN=241 + STDOUT=242 + STORAGE=243 + STORED=244 + STRICT=245 + STRIP=246 + SUBSCRIPTION=247 + SUPPORT=248 + SYSID=249 + SYSTEM=250 + TABLES=251 + TABLESPACE=252 + TEMP=253 + TEMPLATE=254 + TEMPORARY=255 + TEXT=256 + TIES=257 + TRANSACTION=258 + TRANSFORM=259 + TRIGGER=260 + TRUNCATE=261 + TRUSTED=262 + TYPE=263 + TYPES=264 + UNBOUNDED=265 + UNCOMMITTED=266 + UNENCRYPTED=267 + UNKNOWN=268 + UNLISTEN=269 + UNLOGGED=270 + UNTIL=271 + UPDATE=272 + VACUUM=273 + VALID=274 + VALIDATE=275 + VALIDATOR=276 + VALUE=277 + VARYING=278 + VERSION=279 + VIEW=280 + VIEWS=281 + VOLATILE=282 + WHITESPACE=283 + WITHIN=284 + WITHOUT=285 + WORK=286 + WRAPPER=287 + WRITE=288 + XML=289 + YEAR=290 + YES=291 + ZONE=292 + BETWEEN=293 + BIGINT=294 + BIT=295 + BOOLEAN=296 + CHAR=297 + CHARACTER=298 + COALESCE=299 + DEC=300 + DECIMAL=301 + EXISTS=302 + EXTRACT=303 + FLOAT=304 + GREATEST=305 + GROUPING=306 + INOUT=307 + INT=308 + INTEGER=309 + INTERVAL=310 + LEAST=311 + NATIONAL=312 + NCHAR=313 + NONE=314 + NULLIF=315 + NUMERIC=316 + OUT=317 + OVERLAY=318 + POSITION=319 + PRECISION=320 + REAL=321 + ROW=322 + SETOF=323 + SMALLINT=324 + SUBSTRING=325 + TIME=326 + TIMESTAMP=327 + TREAT=328 + TRIM=329 + VALUES=330 + VARCHAR=331 + XMLATTRIBUTES=332 + XMLCONCAT=333 + XMLELEMENT=334 + XMLEXISTS=335 + XMLFOREST=336 + XMLNAMESPACES=337 + XMLPARSE=338 + XMLPI=339 + XMLROOT=340 + XMLSERIALIZE=341 + XMLTABLE=342 + AUTHORIZATION=343 + BINARY=344 + COLLATION=345 + CONCURRENTLY=346 + CROSS=347 + CURRENT_SCHEMA=348 + FREEZE=349 + FULL=350 + ILIKE=351 + INNER=352 + IS=353 + ISNULL=354 + JOIN=355 + LEFT=356 + LIKE=357 + NATURAL=358 + NOTNULL=359 + OUTER=360 + OVERLAPS=361 + RIGHT=362 + SIMILAR=363 + TABLESAMPLE=364 + VERBOSE=365 + ALL=366 + ANALYSE=367 + ANALYZE=368 + AND=369 + ANY=370 + ARRAY=371 + AS=372 + ASC=373 + ASYMMETRIC=374 + BOTH=375 + CASE=376 + CAST=377 + CHECK=378 + COLLATE=379 + COLUMN=380 + CONSTRAINT=381 + CREATE=382 + CURRENT_CATALOG=383 + CURRENT_DATE=384 + CURRENT_ROLE=385 + CURRENT_TIME=386 + CURRENT_TIMESTAMP=387 + CURRENT_USER=388 + DEFAULT=389 + DEFERRABLE=390 + DESC=391 + DISTINCT=392 + DO=393 + ELSE=394 + END=395 + EXCEPT=396 + FALSE=397 + FETCH=398 + FOR=399 + FOREIGN=400 + FROM=401 + GRANT=402 + GROUP=403 + HAVING=404 + IN=405 + INITIALLY=406 + INTERSECT=407 + INTO=408 + LATERAL=409 + LEADING=410 + LIMIT=411 + LOCALTIME=412 + LOCALTIMESTAMP=413 + NOT=414 + NULL=415 + OFFSET=416 + ON=417 + ONLY=418 + OR=419 + ORDER=420 + PLACING=421 + PRIMARY=422 + REFERENCES=423 + RETURNING=424 + SELECT=425 + SESSION_USER=426 + SOME=427 + SYMMETRIC=428 + TABLE=429 + THEN=430 + TO=431 + TRAILING=432 + TRUE=433 + UNION=434 + UNIQUE=435 + USER=436 + USING=437 + VARIADIC=438 + WHEN=439 + WHERE=440 + WINDOW=441 + WITH=442 + ALIGNMENT=443 + BASETYPE=444 + BUFFERS=445 + BYPASSRLS=446 + CANONICAL=447 + CATEGORY=448 + COLLATABLE=449 + COMBINEFUNC=450 + COMMUTATOR=451 + CONNECT=452 + COSTS=453 + CREATEDB=454 + CREATEROLE=455 + DESERIALFUNC=456 + DETERMINISTIC=457 + DISABLE_PAGE_SKIPPING=458 + ELEMENT=459 + EXTENDED=460 + FINALFUNC=461 + FINALFUNC_EXTRA=462 + FINALFUNC_MODIFY=463 + FORCE_NOT_NULL=464 + FORCE_NULL=465 + FORCE_QUOTE=466 + FORMAT=467 + GETTOKEN=468 + HASH=469 + HASHES=470 + HEADLINE=471 + HYPOTHETICAL=472 + INDEX_CLEANUP=473 + INIT=474 + INITCOND=475 + INTERNALLENGTH=476 + JSON=477 + LC_COLLATE=478 + LC_CTYPE=479 + LEFTARG=480 + LEXIZE=481 + LEXTYPES=482 + LIST=483 + LOCALE=484 + LOGIN=485 + MAIN=486 + MERGES=487 + MFINALFUNC=488 + MFINALFUNC_EXTRA=489 + MFINALFUNC_MODIFY=490 + MINITCOND=491 + MINVFUNC=492 + MODULUS=493 + MSFUNC=494 + MSSPACE=495 + MSTYPE=496 + NEGATOR=497 + NOBYPASSRLS=498 + NOCREATEDB=499 + NOCREATEROLE=500 + NOINHERIT=501 + NOLOGIN=502 + NOREPLICATION=503 + NOSUPERUSER=504 + OUTPUT=505 + PASSEDBYVALUE=506 + PATH=507 + PERMISSIVE=508 + PLAIN=509 + PREFERRED=510 + PROVIDER=511 + READ_ONLY=512 + READ_WRITE=513 + RECEIVE=514 + REMAINDER=515 + REPLICATION=516 + RESTRICTED=517 + RESTRICTIVE=518 + RIGHTARG=519 + SAFE=520 + SEND=521 + SERIALFUNC=522 + SETTINGS=523 + SFUNC=524 + SHAREABLE=525 + SKIP_LOCKED=526 + SORTOP=527 + SSPACE=528 + STYPE=529 + SUBTYPE_DIFF=530 + SUBTYPE_OPCLASS=531 + SUBTYPE=532 + SUMMARY=533 + SUPERUSER=534 + TIMING=535 + TYPMOD_IN=536 + TYPMOD_OUT=537 + UNSAFE=538 + USAGE=539 + VARIABLE=540 + YAML=541 + ALIAS=542 + ASSERT=543 + CONSTANT=544 + DATATYPE=545 + DEBUG=546 + DETAIL=547 + DIAGNOSTICS=548 + ELSEIF=549 + ELSIF=550 + ERRCODE=551 + EXIT=552 + EXCEPTION=553 + FOREACH=554 + GET=555 + HINT=556 + INFO=557 + LOG=558 + LOOP=559 + MESSAGE=560 + NOTICE=561 + OPEN=562 + PERFORM=563 + QUERY=564 + RAISE=565 + RECORD=566 + RETURN=567 + REVERSE=568 + ROWTYPE=569 + SLICE=570 + SQLSTATE=571 + STACKED=572 + WARNING=573 + WHILE=574 + CAST_EXPRESSION=575 + EQUAL=576 + COLON=577 + SEMI_COLON=578 + COMMA=579 + NOT_EQUAL=580 + LTH=581 + LEQ=582 + GTH=583 + GEQ=584 + LEFT_PAREN=585 + RIGHT_PAREN=586 + PLUS=587 + MINUS=588 + MULTIPLY=589 + DIVIDE=590 + MODULAR=591 + EXP=592 + DOT=593 + QUOTE_CHAR=594 + DOUBLE_QUOTE=595 + DOLLAR=596 + LEFT_BRACKET=597 + RIGHT_BRACKET=598 + EQUAL_GTH=599 + COLON_EQUAL=600 + LESS_LESS=601 + GREATER_GREATER=602 + DOUBLE_DOT=603 + HASH_SIGN=604 + BlockComment=605 + LineComment=606 + OP_CHARS=607 + NUMBER_LITERAL=608 + REAL_NUMBER=609 + DOLLAR_NUMBER=610 + Identifier=611 + QuotedIdentifier=612 + Character_String_Literal=613 + BeginDollarStringConstant=614 + Space=615 + White_Space=616 + New_Line=617 + Tab=618 + BOM=619 + BAD=620 + Text_between_Dollar=621 + EndDollarStringConstant=622 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class SqlContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EOF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EOF) + else: + return self.getToken(PLpgSQLParser.EOF, i) + + def BOM(self): + return self.getToken(PLpgSQLParser.BOM, 0) + + def SEMI_COLON(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SEMI_COLON) + else: + return self.getToken(PLpgSQLParser.SEMI_COLON, i) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.StatementContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.StatementContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_sql + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSql" ): + listener.enterSql(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSql" ): + listener.exitSql(self) + + + + + def sql(self): + + localctx = PLpgSQLParser.SqlContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_sql) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 761 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BOM: + self.state = 760 + self.match(PLpgSQLParser.BOM) + + + self.state = 766 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.SEMI_COLON: + self.state = 763 + self.match(PLpgSQLParser.SEMI_COLON) + self.state = 768 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 780 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DELETE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (PLpgSQLParser.DISCARD - 67)) | (1 << (PLpgSQLParser.DROP - 67)) | (1 << (PLpgSQLParser.EXECUTE - 67)) | (1 << (PLpgSQLParser.EXPLAIN - 67)) | (1 << (PLpgSQLParser.IMPORT - 67)) | (1 << (PLpgSQLParser.INSERT - 67)) | (1 << (PLpgSQLParser.LISTEN - 67)) | (1 << (PLpgSQLParser.LOAD - 67)))) != 0) or ((((_la - 133)) & ~0x3f) == 0 and ((1 << (_la - 133)) & ((1 << (PLpgSQLParser.LOCK - 133)) | (1 << (PLpgSQLParser.MOVE - 133)) | (1 << (PLpgSQLParser.NOTIFY - 133)) | (1 << (PLpgSQLParser.PREPARE - 133)) | (1 << (PLpgSQLParser.REASSIGN - 133)) | (1 << (PLpgSQLParser.REFRESH - 133)))) != 0) or ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & ((1 << (PLpgSQLParser.REINDEX - 197)) | (1 << (PLpgSQLParser.RELEASE - 197)) | (1 << (PLpgSQLParser.RESET - 197)) | (1 << (PLpgSQLParser.REVOKE - 197)) | (1 << (PLpgSQLParser.ROLLBACK - 197)) | (1 << (PLpgSQLParser.SAVEPOINT - 197)) | (1 << (PLpgSQLParser.SECURITY - 197)) | (1 << (PLpgSQLParser.SET - 197)) | (1 << (PLpgSQLParser.SHOW - 197)) | (1 << (PLpgSQLParser.START - 197)))) != 0) or ((((_la - 261)) & ~0x3f) == 0 and ((1 << (_la - 261)) & ((1 << (PLpgSQLParser.TRUNCATE - 261)) | (1 << (PLpgSQLParser.UNLISTEN - 261)) | (1 << (PLpgSQLParser.UPDATE - 261)) | (1 << (PLpgSQLParser.VACUUM - 261)))) != 0) or ((((_la - 330)) & ~0x3f) == 0 and ((1 << (_la - 330)) & ((1 << (PLpgSQLParser.VALUES - 330)) | (1 << (PLpgSQLParser.ANALYZE - 330)) | (1 << (PLpgSQLParser.CREATE - 330)) | (1 << (PLpgSQLParser.DO - 330)))) != 0) or ((((_la - 395)) & ~0x3f) == 0 and ((1 << (_la - 395)) & ((1 << (PLpgSQLParser.END - 395)) | (1 << (PLpgSQLParser.FETCH - 395)) | (1 << (PLpgSQLParser.GRANT - 395)) | (1 << (PLpgSQLParser.SELECT - 395)) | (1 << (PLpgSQLParser.TABLE - 395)) | (1 << (PLpgSQLParser.WITH - 395)))) != 0) or _la==PLpgSQLParser.LEFT_PAREN: + self.state = 769 + self.statement() + self.state = 776 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SEMI_COLON]: + self.state = 771 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 770 + self.match(PLpgSQLParser.SEMI_COLON) + self.state = 773 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.SEMI_COLON): + break + + pass + elif token in [PLpgSQLParser.EOF]: + self.state = 775 + self.match(PLpgSQLParser.EOF) + pass + else: + raise NoViableAltException(self) + + self.state = 782 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 783 + self.match(PLpgSQLParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Qname_parserContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def EOF(self): + return self.getToken(PLpgSQLParser.EOF, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_qname_parser + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQname_parser" ): + listener.enterQname_parser(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQname_parser" ): + listener.exitQname_parser(self) + + + + + def qname_parser(self): + + localctx = PLpgSQLParser.Qname_parserContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_qname_parser) + try: + self.enterOuterAlt(localctx, 1) + self.state = 785 + self.schema_qualified_name() + self.state = 786 + self.match(PLpgSQLParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_args_parserContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def EOF(self): + return self.getToken(PLpgSQLParser.EOF, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_args_parser + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_args_parser" ): + listener.enterFunction_args_parser(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_args_parser" ): + listener.exitFunction_args_parser(self) + + + + + def function_args_parser(self): + + localctx = PLpgSQLParser.Function_args_parserContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_function_args_parser) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 789 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 788 + self.schema_qualified_name() + + + self.state = 791 + self.function_args() + self.state = 792 + self.match(PLpgSQLParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Vex_eofContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def EOF(self): + return self.getToken(PLpgSQLParser.EOF, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_vex_eof + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVex_eof" ): + listener.enterVex_eof(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVex_eof" ): + listener.exitVex_eof(self) + + + + + def vex_eof(self): + + localctx = PLpgSQLParser.Vex_eofContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_vex_eof) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 794 + self.vex(0) + self.state = 799 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 795 + self.match(PLpgSQLParser.COMMA) + self.state = 796 + self.vex(0) + self.state = 801 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 802 + self.match(PLpgSQLParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Plpgsql_functionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def function_block(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_blockContext,0) + + + def EOF(self): + return self.getToken(PLpgSQLParser.EOF, 0) + + def comp_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Comp_optionsContext,0) + + + def SEMI_COLON(self): + return self.getToken(PLpgSQLParser.SEMI_COLON, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_plpgsql_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPlpgsql_function" ): + listener.enterPlpgsql_function(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPlpgsql_function" ): + listener.exitPlpgsql_function(self) + + + + + def plpgsql_function(self): + + localctx = PLpgSQLParser.Plpgsql_functionContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_plpgsql_function) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 805 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.HASH_SIGN: + self.state = 804 + self.comp_options() + + + self.state = 807 + self.function_block() + self.state = 809 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.SEMI_COLON: + self.state = 808 + self.match(PLpgSQLParser.SEMI_COLON) + + + self.state = 811 + self.match(PLpgSQLParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Plpgsql_function_test_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EOF(self): + return self.getToken(PLpgSQLParser.EOF, 0) + + def function_block(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_blockContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_blockContext,i) + + + def SEMI_COLON(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SEMI_COLON) + else: + return self.getToken(PLpgSQLParser.SEMI_COLON, i) + + def comp_options(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Comp_optionsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Comp_optionsContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_plpgsql_function_test_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPlpgsql_function_test_list" ): + listener.enterPlpgsql_function_test_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPlpgsql_function_test_list" ): + listener.exitPlpgsql_function_test_list(self) + + + + + def plpgsql_function_test_list(self): + + localctx = PLpgSQLParser.Plpgsql_function_test_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_plpgsql_function_test_list) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 821 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.BEGIN or _la==PLpgSQLParser.DECLARE or _la==PLpgSQLParser.LESS_LESS or _la==PLpgSQLParser.HASH_SIGN: + self.state = 814 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.HASH_SIGN: + self.state = 813 + self.comp_options() + + + self.state = 816 + self.function_block() + self.state = 817 + self.match(PLpgSQLParser.SEMI_COLON) + self.state = 823 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 824 + self.match(PLpgSQLParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StatementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_statementContext,0) + + + def schema_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_statementContext,0) + + + def script_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Script_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStatement" ): + listener.enterStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStatement" ): + listener.exitStatement(self) + + + + + def statement(self): + + localctx = PLpgSQLParser.StatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_statement) + try: + self.state = 829 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DELETE, PLpgSQLParser.INSERT, PLpgSQLParser.UPDATE, PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE, PLpgSQLParser.WITH, PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 1) + self.state = 826 + self.data_statement() + pass + elif token in [PLpgSQLParser.ALTER, PLpgSQLParser.COMMENT, PLpgSQLParser.DROP, PLpgSQLParser.IMPORT, PLpgSQLParser.REVOKE, PLpgSQLParser.SECURITY, PLpgSQLParser.SET, PLpgSQLParser.CREATE, PLpgSQLParser.GRANT]: + self.enterOuterAlt(localctx, 2) + self.state = 827 + self.schema_statement() + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.BEGIN, PLpgSQLParser.CALL, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COMMIT, PLpgSQLParser.COPY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DISCARD, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCK, PLpgSQLParser.MOVE, PLpgSQLParser.NOTIFY, PLpgSQLParser.PREPARE, PLpgSQLParser.REASSIGN, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELEASE, PLpgSQLParser.RESET, PLpgSQLParser.ROLLBACK, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SHOW, PLpgSQLParser.START, PLpgSQLParser.TRUNCATE, PLpgSQLParser.UNLISTEN, PLpgSQLParser.VACUUM, PLpgSQLParser.ANALYZE, PLpgSQLParser.DO, PLpgSQLParser.END, PLpgSQLParser.FETCH]: + self.enterOuterAlt(localctx, 3) + self.state = 828 + self.script_statement() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Data_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def insert_stmt_for_psql(self): + return self.getTypedRuleContext(PLpgSQLParser.Insert_stmt_for_psqlContext,0) + + + def update_stmt_for_psql(self): + return self.getTypedRuleContext(PLpgSQLParser.Update_stmt_for_psqlContext,0) + + + def delete_stmt_for_psql(self): + return self.getTypedRuleContext(PLpgSQLParser.Delete_stmt_for_psqlContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_data_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterData_statement" ): + listener.enterData_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitData_statement" ): + listener.exitData_statement(self) + + + + + def data_statement(self): + + localctx = PLpgSQLParser.Data_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_data_statement) + try: + self.state = 835 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 831 + self.select_stmt() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 832 + self.insert_stmt_for_psql() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 833 + self.update_stmt_for_psql() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 834 + self.delete_stmt_for_psql() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Script_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def script_transaction(self): + return self.getTypedRuleContext(PLpgSQLParser.Script_transactionContext,0) + + + def script_additional(self): + return self.getTypedRuleContext(PLpgSQLParser.Script_additionalContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_script_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScript_statement" ): + listener.enterScript_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScript_statement" ): + listener.exitScript_statement(self) + + + + + def script_statement(self): + + localctx = PLpgSQLParser.Script_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_script_statement) + try: + self.state = 839 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,13,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 837 + self.script_transaction() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 838 + self.script_additional() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Script_transactionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def START(self): + return self.getToken(PLpgSQLParser.START, 0) + + def TRANSACTION(self): + return self.getToken(PLpgSQLParser.TRANSACTION, 0) + + def BEGIN(self): + return self.getToken(PLpgSQLParser.BEGIN, 0) + + def transaction_mode(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Transaction_modeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Transaction_modeContext,i) + + + def WORK(self): + return self.getToken(PLpgSQLParser.WORK, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def COMMIT(self): + return self.getToken(PLpgSQLParser.COMMIT, 0) + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def ABORT(self): + return self.getToken(PLpgSQLParser.ABORT, 0) + + def ROLLBACK(self): + return self.getToken(PLpgSQLParser.ROLLBACK, 0) + + def AND(self): + return self.getToken(PLpgSQLParser.AND, 0) + + def CHAIN(self): + return self.getToken(PLpgSQLParser.CHAIN, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def PREPARED(self): + return self.getToken(PLpgSQLParser.PREPARED, 0) + + def PREPARE(self): + return self.getToken(PLpgSQLParser.PREPARE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def SAVEPOINT(self): + return self.getToken(PLpgSQLParser.SAVEPOINT, 0) + + def RELEASE(self): + return self.getToken(PLpgSQLParser.RELEASE, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def lock_table(self): + return self.getTypedRuleContext(PLpgSQLParser.Lock_tableContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_script_transaction + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScript_transaction" ): + listener.enterScript_transaction(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScript_transaction" ): + listener.exitScript_transaction(self) + + + + + def script_transaction(self): + + localctx = PLpgSQLParser.Script_transactionContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_script_transaction) + self._la = 0 # Token type + try: + self.state = 898 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,26,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 847 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.START]: + self.state = 841 + self.match(PLpgSQLParser.START) + self.state = 842 + self.match(PLpgSQLParser.TRANSACTION) + pass + elif token in [PLpgSQLParser.BEGIN]: + self.state = 843 + self.match(PLpgSQLParser.BEGIN) + self.state = 845 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TRANSACTION or _la==PLpgSQLParser.WORK: + self.state = 844 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TRANSACTION or _la==PLpgSQLParser.WORK): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + pass + else: + raise NoViableAltException(self) + + self.state = 857 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ISOLATION or _la==PLpgSQLParser.READ or _la==PLpgSQLParser.DEFERRABLE or _la==PLpgSQLParser.NOT: + self.state = 849 + self.transaction_mode() + self.state = 854 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 850 + self.match(PLpgSQLParser.COMMA) + self.state = 851 + self.transaction_mode() + self.state = 856 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 859 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ABORT or _la==PLpgSQLParser.COMMIT or _la==PLpgSQLParser.ROLLBACK or _la==PLpgSQLParser.END): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 861 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TRANSACTION or _la==PLpgSQLParser.WORK: + self.state = 860 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TRANSACTION or _la==PLpgSQLParser.WORK): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 868 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AND: + self.state = 863 + self.match(PLpgSQLParser.AND) + self.state = 865 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 864 + self.match(PLpgSQLParser.NO) + + + self.state = 867 + self.match(PLpgSQLParser.CHAIN) + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 874 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.COMMIT]: + self.state = 870 + self.match(PLpgSQLParser.COMMIT) + self.state = 871 + self.match(PLpgSQLParser.PREPARED) + pass + elif token in [PLpgSQLParser.PREPARE]: + self.state = 872 + self.match(PLpgSQLParser.PREPARE) + self.state = 873 + self.match(PLpgSQLParser.TRANSACTION) + pass + else: + raise NoViableAltException(self) + + self.state = 876 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 882 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SAVEPOINT]: + self.state = 877 + self.match(PLpgSQLParser.SAVEPOINT) + pass + elif token in [PLpgSQLParser.RELEASE]: + self.state = 878 + self.match(PLpgSQLParser.RELEASE) + self.state = 880 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,22,self._ctx) + if la_ == 1: + self.state = 879 + self.match(PLpgSQLParser.SAVEPOINT) + + + pass + else: + raise NoViableAltException(self) + + self.state = 884 + self.identifier() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 885 + self.match(PLpgSQLParser.ROLLBACK) + self.state = 886 + self.match(PLpgSQLParser.PREPARED) + self.state = 887 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 888 + self.match(PLpgSQLParser.ROLLBACK) + self.state = 890 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TRANSACTION or _la==PLpgSQLParser.WORK: + self.state = 889 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TRANSACTION or _la==PLpgSQLParser.WORK): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 892 + self.match(PLpgSQLParser.TO) + self.state = 894 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,25,self._ctx) + if la_ == 1: + self.state = 893 + self.match(PLpgSQLParser.SAVEPOINT) + + + self.state = 896 + self.identifier() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 897 + self.lock_table() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Transaction_modeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ISOLATION(self): + return self.getToken(PLpgSQLParser.ISOLATION, 0) + + def LEVEL(self): + return self.getToken(PLpgSQLParser.LEVEL, 0) + + def SERIALIZABLE(self): + return self.getToken(PLpgSQLParser.SERIALIZABLE, 0) + + def REPEATABLE(self): + return self.getToken(PLpgSQLParser.REPEATABLE, 0) + + def READ(self): + return self.getToken(PLpgSQLParser.READ, 0) + + def COMMITTED(self): + return self.getToken(PLpgSQLParser.COMMITTED, 0) + + def UNCOMMITTED(self): + return self.getToken(PLpgSQLParser.UNCOMMITTED, 0) + + def WRITE(self): + return self.getToken(PLpgSQLParser.WRITE, 0) + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def DEFERRABLE(self): + return self.getToken(PLpgSQLParser.DEFERRABLE, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_transaction_mode + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTransaction_mode" ): + listener.enterTransaction_mode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTransaction_mode" ): + listener.exitTransaction_mode(self) + + + + + def transaction_mode(self): + + localctx = PLpgSQLParser.Transaction_modeContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_transaction_mode) + self._la = 0 # Token type + try: + self.state = 919 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,29,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 900 + self.match(PLpgSQLParser.ISOLATION) + self.state = 901 + self.match(PLpgSQLParser.LEVEL) + self.state = 909 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,27,self._ctx) + if la_ == 1: + self.state = 902 + self.match(PLpgSQLParser.SERIALIZABLE) + pass + + elif la_ == 2: + self.state = 903 + self.match(PLpgSQLParser.REPEATABLE) + self.state = 904 + self.match(PLpgSQLParser.READ) + pass + + elif la_ == 3: + self.state = 905 + self.match(PLpgSQLParser.READ) + self.state = 906 + self.match(PLpgSQLParser.COMMITTED) + pass + + elif la_ == 4: + self.state = 907 + self.match(PLpgSQLParser.READ) + self.state = 908 + self.match(PLpgSQLParser.UNCOMMITTED) + pass + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 911 + self.match(PLpgSQLParser.READ) + self.state = 912 + self.match(PLpgSQLParser.WRITE) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 913 + self.match(PLpgSQLParser.READ) + self.state = 914 + self.match(PLpgSQLParser.ONLY) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 916 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 915 + self.match(PLpgSQLParser.NOT) + + + self.state = 918 + self.match(PLpgSQLParser.DEFERRABLE) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Lock_tableContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LOCK(self): + return self.getToken(PLpgSQLParser.LOCK, 0) + + def only_table_multiply(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Only_table_multiplyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Only_table_multiplyContext,i) + + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def lock_mode(self): + return self.getTypedRuleContext(PLpgSQLParser.Lock_modeContext,0) + + + def MODE(self): + return self.getToken(PLpgSQLParser.MODE, 0) + + def NOWAIT(self): + return self.getToken(PLpgSQLParser.NOWAIT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_lock_table + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLock_table" ): + listener.enterLock_table(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLock_table" ): + listener.exitLock_table(self) + + + + + def lock_table(self): + + localctx = PLpgSQLParser.Lock_tableContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_lock_table) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 921 + self.match(PLpgSQLParser.LOCK) + self.state = 923 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLE: + self.state = 922 + self.match(PLpgSQLParser.TABLE) + + + self.state = 925 + self.only_table_multiply() + self.state = 930 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 926 + self.match(PLpgSQLParser.COMMA) + self.state = 927 + self.only_table_multiply() + self.state = 932 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 937 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IN: + self.state = 933 + self.match(PLpgSQLParser.IN) + self.state = 934 + self.lock_mode() + self.state = 935 + self.match(PLpgSQLParser.MODE) + + + self.state = 940 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOWAIT: + self.state = 939 + self.match(PLpgSQLParser.NOWAIT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Lock_modeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SHARE(self): + return self.getToken(PLpgSQLParser.SHARE, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def ACCESS(self): + return self.getToken(PLpgSQLParser.ACCESS, 0) + + def EXCLUSIVE(self): + return self.getToken(PLpgSQLParser.EXCLUSIVE, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_lock_mode + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLock_mode" ): + listener.enterLock_mode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLock_mode" ): + listener.exitLock_mode(self) + + + + + def lock_mode(self): + + localctx = PLpgSQLParser.Lock_modeContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_lock_mode) + self._la = 0 # Token type + try: + self.state = 954 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,35,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 942 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ACCESS or _la==PLpgSQLParser.ROW): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 943 + self.match(PLpgSQLParser.SHARE) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 944 + self.match(PLpgSQLParser.ROW) + self.state = 945 + self.match(PLpgSQLParser.EXCLUSIVE) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 946 + self.match(PLpgSQLParser.SHARE) + self.state = 947 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.UPDATE or _la==PLpgSQLParser.ROW): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 948 + self.match(PLpgSQLParser.EXCLUSIVE) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 949 + self.match(PLpgSQLParser.SHARE) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 951 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ACCESS: + self.state = 950 + self.match(PLpgSQLParser.ACCESS) + + + self.state = 953 + self.match(PLpgSQLParser.EXCLUSIVE) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Script_additionalContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def additional_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Additional_statementContext,0) + + + def VACUUM(self): + return self.getToken(PLpgSQLParser.VACUUM, 0) + + def vacuum_mode(self): + return self.getTypedRuleContext(PLpgSQLParser.Vacuum_modeContext,0) + + + def table_cols_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_cols_listContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def FETCH(self): + return self.getToken(PLpgSQLParser.FETCH, 0) + + def MOVE(self): + return self.getToken(PLpgSQLParser.MOVE, 0) + + def fetch_move_direction(self): + return self.getTypedRuleContext(PLpgSQLParser.Fetch_move_directionContext,0) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def CLOSE(self): + return self.getToken(PLpgSQLParser.CLOSE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def CALL(self): + return self.getToken(PLpgSQLParser.CALL, 0) + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def DISCARD(self): + return self.getToken(PLpgSQLParser.DISCARD, 0) + + def PLANS(self): + return self.getToken(PLpgSQLParser.PLANS, 0) + + def SEQUENCES(self): + return self.getToken(PLpgSQLParser.SEQUENCES, 0) + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def declare_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Declare_statementContext,0) + + + def execute_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Execute_statementContext,0) + + + def explain_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Explain_statementContext,0) + + + def show_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Show_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_script_additional + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScript_additional" ): + listener.enterScript_additional(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScript_additional" ): + listener.exitScript_additional(self) + + + + + def script_additional(self): + + localctx = PLpgSQLParser.Script_additionalContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_script_additional) + self._la = 0 # Token type + try: + self.state = 983 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLUSTER, PLpgSQLParser.COPY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.NOTIFY, PLpgSQLParser.PREPARE, PLpgSQLParser.REASSIGN, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RESET, PLpgSQLParser.TRUNCATE, PLpgSQLParser.UNLISTEN, PLpgSQLParser.ANALYZE, PLpgSQLParser.DO]: + self.enterOuterAlt(localctx, 1) + self.state = 956 + self.additional_statement() + pass + elif token in [PLpgSQLParser.VACUUM]: + self.enterOuterAlt(localctx, 2) + self.state = 957 + self.match(PLpgSQLParser.VACUUM) + self.state = 958 + self.vacuum_mode() + self.state = 960 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 959 + self.table_cols_list() + + + pass + elif token in [PLpgSQLParser.MOVE, PLpgSQLParser.FETCH]: + self.enterOuterAlt(localctx, 3) + self.state = 962 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.MOVE or _la==PLpgSQLParser.FETCH): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 964 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,37,self._ctx) + if la_ == 1: + self.state = 963 + self.fetch_move_direction() + + + self.state = 967 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM or _la==PLpgSQLParser.IN: + self.state = 966 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FROM or _la==PLpgSQLParser.IN): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 969 + self.identifier() + pass + elif token in [PLpgSQLParser.CLOSE]: + self.enterOuterAlt(localctx, 4) + self.state = 970 + self.match(PLpgSQLParser.CLOSE) + self.state = 973 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 971 + self.identifier() + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 972 + self.match(PLpgSQLParser.ALL) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.CALL]: + self.enterOuterAlt(localctx, 5) + self.state = 975 + self.match(PLpgSQLParser.CALL) + self.state = 976 + self.function_call() + pass + elif token in [PLpgSQLParser.DISCARD]: + self.enterOuterAlt(localctx, 6) + self.state = 977 + self.match(PLpgSQLParser.DISCARD) + self.state = 978 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PLANS or _la==PLpgSQLParser.SEQUENCES or _la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY or _la==PLpgSQLParser.ALL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.DECLARE]: + self.enterOuterAlt(localctx, 7) + self.state = 979 + self.declare_statement() + pass + elif token in [PLpgSQLParser.EXECUTE]: + self.enterOuterAlt(localctx, 8) + self.state = 980 + self.execute_statement() + pass + elif token in [PLpgSQLParser.EXPLAIN]: + self.enterOuterAlt(localctx, 9) + self.state = 981 + self.explain_statement() + pass + elif token in [PLpgSQLParser.SHOW]: + self.enterOuterAlt(localctx, 10) + self.state = 982 + self.show_statement() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Additional_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def anonymous_block(self): + return self.getTypedRuleContext(PLpgSQLParser.Anonymous_blockContext,0) + + + def LISTEN(self): + return self.getToken(PLpgSQLParser.LISTEN, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def UNLISTEN(self): + return self.getToken(PLpgSQLParser.UNLISTEN, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def ANALYZE(self): + return self.getToken(PLpgSQLParser.ANALYZE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def analyze_mode(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Analyze_modeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Analyze_modeContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def table_cols_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_cols_listContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def CLUSTER(self): + return self.getToken(PLpgSQLParser.CLUSTER, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def CHECKPOINT(self): + return self.getToken(PLpgSQLParser.CHECKPOINT, 0) + + def LOAD(self): + return self.getToken(PLpgSQLParser.LOAD, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def DEALLOCATE(self): + return self.getToken(PLpgSQLParser.DEALLOCATE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def PREPARE(self): + return self.getToken(PLpgSQLParser.PREPARE, 0) + + def REINDEX(self): + return self.getToken(PLpgSQLParser.REINDEX, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def SYSTEM(self): + return self.getToken(PLpgSQLParser.SYSTEM, 0) + + def CONCURRENTLY(self): + return self.getToken(PLpgSQLParser.CONCURRENTLY, 0) + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def TIME(self): + return self.getToken(PLpgSQLParser.TIME, 0) + + def ZONE(self): + return self.getToken(PLpgSQLParser.ZONE, 0) + + def SESSION(self): + return self.getToken(PLpgSQLParser.SESSION, 0) + + def AUTHORIZATION(self): + return self.getToken(PLpgSQLParser.AUTHORIZATION, 0) + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def REFRESH(self): + return self.getToken(PLpgSQLParser.REFRESH, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def data_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_statementContext,0) + + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def REASSIGN(self): + return self.getToken(PLpgSQLParser.REASSIGN, 0) + + def OWNED(self): + return self.getToken(PLpgSQLParser.OWNED, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def user_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.User_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,i) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def copy_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Copy_statementContext,0) + + + def truncate_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Truncate_stmtContext,0) + + + def notify_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Notify_stmtContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_additional_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAdditional_statement" ): + listener.enterAdditional_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAdditional_statement" ): + listener.exitAdditional_statement(self) + + + + + def additional_statement(self): + + localctx = PLpgSQLParser.Additional_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_additional_statement) + self._la = 0 # Token type + try: + self.state = 1111 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DO]: + self.enterOuterAlt(localctx, 1) + self.state = 985 + self.anonymous_block() + pass + elif token in [PLpgSQLParser.LISTEN]: + self.enterOuterAlt(localctx, 2) + self.state = 986 + self.match(PLpgSQLParser.LISTEN) + self.state = 987 + self.identifier() + pass + elif token in [PLpgSQLParser.UNLISTEN]: + self.enterOuterAlt(localctx, 3) + self.state = 988 + self.match(PLpgSQLParser.UNLISTEN) + self.state = 991 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 989 + self.identifier() + pass + elif token in [PLpgSQLParser.MULTIPLY]: + self.state = 990 + self.match(PLpgSQLParser.MULTIPLY) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.ANALYZE]: + self.enterOuterAlt(localctx, 4) + self.state = 993 + self.match(PLpgSQLParser.ANALYZE) + self.state = 1006 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 994 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 995 + self.analyze_mode() + self.state = 1000 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 996 + self.match(PLpgSQLParser.COMMA) + self.state = 997 + self.analyze_mode() + self.state = 1002 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1003 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.VERBOSE]: + self.state = 1005 + self.match(PLpgSQLParser.VERBOSE) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.SEMI_COLON, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + pass + else: + pass + self.state = 1009 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 1008 + self.table_cols_list() + + + pass + elif token in [PLpgSQLParser.CLUSTER]: + self.enterOuterAlt(localctx, 5) + self.state = 1011 + self.match(PLpgSQLParser.CLUSTER) + self.state = 1013 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERBOSE: + self.state = 1012 + self.match(PLpgSQLParser.VERBOSE) + + + self.state = 1024 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,47,self._ctx) + if la_ == 1: + self.state = 1015 + self.identifier() + self.state = 1016 + self.match(PLpgSQLParser.ON) + self.state = 1017 + self.schema_qualified_name() + + elif la_ == 2: + self.state = 1019 + self.schema_qualified_name() + self.state = 1022 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 1020 + self.match(PLpgSQLParser.USING) + self.state = 1021 + self.identifier() + + + + + pass + elif token in [PLpgSQLParser.CHECKPOINT]: + self.enterOuterAlt(localctx, 6) + self.state = 1026 + self.match(PLpgSQLParser.CHECKPOINT) + pass + elif token in [PLpgSQLParser.LOAD]: + self.enterOuterAlt(localctx, 7) + self.state = 1027 + self.match(PLpgSQLParser.LOAD) + self.state = 1028 + self.match(PLpgSQLParser.Character_String_Literal) + pass + elif token in [PLpgSQLParser.DEALLOCATE]: + self.enterOuterAlt(localctx, 8) + self.state = 1029 + self.match(PLpgSQLParser.DEALLOCATE) + self.state = 1031 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,48,self._ctx) + if la_ == 1: + self.state = 1030 + self.match(PLpgSQLParser.PREPARE) + + + self.state = 1035 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 1033 + self.identifier() + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 1034 + self.match(PLpgSQLParser.ALL) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.REINDEX]: + self.enterOuterAlt(localctx, 9) + self.state = 1037 + self.match(PLpgSQLParser.REINDEX) + self.state = 1041 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 1038 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1039 + self.match(PLpgSQLParser.VERBOSE) + self.state = 1040 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 1043 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DATABASE or _la==PLpgSQLParser.INDEX or _la==PLpgSQLParser.SCHEMA or _la==PLpgSQLParser.SYSTEM or _la==PLpgSQLParser.TABLE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1045 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONCURRENTLY: + self.state = 1044 + self.match(PLpgSQLParser.CONCURRENTLY) + + + self.state = 1047 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.RESET]: + self.enterOuterAlt(localctx, 10) + self.state = 1048 + self.match(PLpgSQLParser.RESET) + self.state = 1060 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,53,self._ctx) + if la_ == 1: + self.state = 1052 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,52,self._ctx) + if la_ == 1: + self.state = 1049 + self.identifier() + self.state = 1050 + self.match(PLpgSQLParser.DOT) + + + self.state = 1054 + self.identifier() + pass + + elif la_ == 2: + self.state = 1055 + self.match(PLpgSQLParser.TIME) + self.state = 1056 + self.match(PLpgSQLParser.ZONE) + pass + + elif la_ == 3: + self.state = 1057 + self.match(PLpgSQLParser.SESSION) + self.state = 1058 + self.match(PLpgSQLParser.AUTHORIZATION) + pass + + elif la_ == 4: + self.state = 1059 + self.match(PLpgSQLParser.ALL) + pass + + + pass + elif token in [PLpgSQLParser.REFRESH]: + self.enterOuterAlt(localctx, 11) + self.state = 1062 + self.match(PLpgSQLParser.REFRESH) + self.state = 1063 + self.match(PLpgSQLParser.MATERIALIZED) + self.state = 1064 + self.match(PLpgSQLParser.VIEW) + self.state = 1066 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONCURRENTLY: + self.state = 1065 + self.match(PLpgSQLParser.CONCURRENTLY) + + + self.state = 1068 + self.schema_qualified_name() + self.state = 1074 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 1069 + self.match(PLpgSQLParser.WITH) + self.state = 1071 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 1070 + self.match(PLpgSQLParser.NO) + + + self.state = 1073 + self.match(PLpgSQLParser.DATA) + + + pass + elif token in [PLpgSQLParser.PREPARE]: + self.enterOuterAlt(localctx, 12) + self.state = 1076 + self.match(PLpgSQLParser.PREPARE) + self.state = 1077 + self.identifier() + self.state = 1089 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 1078 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1079 + self.data_type() + self.state = 1084 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1080 + self.match(PLpgSQLParser.COMMA) + self.state = 1081 + self.data_type() + self.state = 1086 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1087 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 1091 + self.match(PLpgSQLParser.AS) + self.state = 1092 + self.data_statement() + pass + elif token in [PLpgSQLParser.REASSIGN]: + self.enterOuterAlt(localctx, 13) + self.state = 1094 + self.match(PLpgSQLParser.REASSIGN) + self.state = 1095 + self.match(PLpgSQLParser.OWNED) + self.state = 1096 + self.match(PLpgSQLParser.BY) + self.state = 1097 + self.user_name() + self.state = 1102 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1098 + self.match(PLpgSQLParser.COMMA) + self.state = 1099 + self.user_name() + self.state = 1104 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1105 + self.match(PLpgSQLParser.TO) + self.state = 1106 + self.user_name() + pass + elif token in [PLpgSQLParser.COPY]: + self.enterOuterAlt(localctx, 14) + self.state = 1108 + self.copy_statement() + pass + elif token in [PLpgSQLParser.TRUNCATE]: + self.enterOuterAlt(localctx, 15) + self.state = 1109 + self.truncate_stmt() + pass + elif token in [PLpgSQLParser.NOTIFY]: + self.enterOuterAlt(localctx, 16) + self.state = 1110 + self.notify_stmt() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Explain_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXPLAIN(self): + return self.getToken(PLpgSQLParser.EXPLAIN, 0) + + def explain_query(self): + return self.getTypedRuleContext(PLpgSQLParser.Explain_queryContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def explain_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Explain_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Explain_optionContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def ANALYZE(self): + return self.getToken(PLpgSQLParser.ANALYZE, 0) + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_explain_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExplain_statement" ): + listener.enterExplain_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExplain_statement" ): + listener.exitExplain_statement(self) + + + + + def explain_statement(self): + + localctx = PLpgSQLParser.Explain_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_explain_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1113 + self.match(PLpgSQLParser.EXPLAIN) + self.state = 1131 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,64,self._ctx) + if la_ == 1: + self.state = 1115 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ANALYZE: + self.state = 1114 + self.match(PLpgSQLParser.ANALYZE) + + + self.state = 1118 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERBOSE: + self.state = 1117 + self.match(PLpgSQLParser.VERBOSE) + + + pass + + elif la_ == 2: + self.state = 1120 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1121 + self.explain_option() + self.state = 1126 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1122 + self.match(PLpgSQLParser.COMMA) + self.state = 1123 + self.explain_option() + self.state = 1128 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1129 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + + self.state = 1133 + self.explain_query() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Explain_queryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_statementContext,0) + + + def execute_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Execute_statementContext,0) + + + def declare_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Declare_statementContext,0) + + + def CREATE(self): + return self.getToken(PLpgSQLParser.CREATE, 0) + + def create_table_as_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_table_as_statementContext,0) + + + def create_view_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_view_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_explain_query + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExplain_query" ): + listener.enterExplain_query(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExplain_query" ): + listener.exitExplain_query(self) + + + + + def explain_query(self): + + localctx = PLpgSQLParser.Explain_queryContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_explain_query) + try: + self.state = 1143 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DELETE, PLpgSQLParser.INSERT, PLpgSQLParser.UPDATE, PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE, PLpgSQLParser.WITH, PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 1) + self.state = 1135 + self.data_statement() + pass + elif token in [PLpgSQLParser.EXECUTE]: + self.enterOuterAlt(localctx, 2) + self.state = 1136 + self.execute_statement() + pass + elif token in [PLpgSQLParser.DECLARE]: + self.enterOuterAlt(localctx, 3) + self.state = 1137 + self.declare_statement() + pass + elif token in [PLpgSQLParser.CREATE]: + self.enterOuterAlt(localctx, 4) + self.state = 1138 + self.match(PLpgSQLParser.CREATE) + self.state = 1141 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,65,self._ctx) + if la_ == 1: + self.state = 1139 + self.create_table_as_statement() + pass + + elif la_ == 2: + self.state = 1140 + self.create_view_statement() + pass + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Execute_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_execute_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecute_statement" ): + listener.enterExecute_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecute_statement" ): + listener.exitExecute_statement(self) + + + + + def execute_statement(self): + + localctx = PLpgSQLParser.Execute_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_execute_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1145 + self.match(PLpgSQLParser.EXECUTE) + self.state = 1146 + self.identifier() + self.state = 1158 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 1147 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1148 + self.vex(0) + self.state = 1153 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1149 + self.match(PLpgSQLParser.COMMA) + self.state = 1150 + self.vex(0) + self.state = 1155 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1156 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Declare_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DECLARE(self): + return self.getToken(PLpgSQLParser.DECLARE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def CURSOR(self): + return self.getToken(PLpgSQLParser.CURSOR, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def BINARY(self): + return self.getToken(PLpgSQLParser.BINARY, 0) + + def INSENSITIVE(self): + return self.getToken(PLpgSQLParser.INSENSITIVE, 0) + + def SCROLL(self): + return self.getToken(PLpgSQLParser.SCROLL, 0) + + def HOLD(self): + return self.getToken(PLpgSQLParser.HOLD, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def WITHOUT(self): + return self.getToken(PLpgSQLParser.WITHOUT, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_declare_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDeclare_statement" ): + listener.enterDeclare_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDeclare_statement" ): + listener.exitDeclare_statement(self) + + + + + def declare_statement(self): + + localctx = PLpgSQLParser.Declare_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_declare_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1160 + self.match(PLpgSQLParser.DECLARE) + self.state = 1161 + self.identifier() + self.state = 1163 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BINARY: + self.state = 1162 + self.match(PLpgSQLParser.BINARY) + + + self.state = 1166 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INSENSITIVE: + self.state = 1165 + self.match(PLpgSQLParser.INSENSITIVE) + + + self.state = 1172 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO or _la==PLpgSQLParser.SCROLL: + self.state = 1169 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 1168 + self.match(PLpgSQLParser.NO) + + + self.state = 1171 + self.match(PLpgSQLParser.SCROLL) + + + self.state = 1174 + self.match(PLpgSQLParser.CURSOR) + self.state = 1177 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITHOUT or _la==PLpgSQLParser.WITH: + self.state = 1175 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.WITHOUT or _la==PLpgSQLParser.WITH): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1176 + self.match(PLpgSQLParser.HOLD) + + + self.state = 1179 + self.match(PLpgSQLParser.FOR) + self.state = 1180 + self.select_stmt() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Show_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SHOW(self): + return self.getToken(PLpgSQLParser.SHOW, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def TIME(self): + return self.getToken(PLpgSQLParser.TIME, 0) + + def ZONE(self): + return self.getToken(PLpgSQLParser.ZONE, 0) + + def TRANSACTION(self): + return self.getToken(PLpgSQLParser.TRANSACTION, 0) + + def ISOLATION(self): + return self.getToken(PLpgSQLParser.ISOLATION, 0) + + def LEVEL(self): + return self.getToken(PLpgSQLParser.LEVEL, 0) + + def SESSION(self): + return self.getToken(PLpgSQLParser.SESSION, 0) + + def AUTHORIZATION(self): + return self.getToken(PLpgSQLParser.AUTHORIZATION, 0) + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_show_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterShow_statement" ): + listener.enterShow_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitShow_statement" ): + listener.exitShow_statement(self) + + + + + def show_statement(self): + + localctx = PLpgSQLParser.Show_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_show_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1182 + self.match(PLpgSQLParser.SHOW) + self.state = 1197 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,75,self._ctx) + if la_ == 1: + self.state = 1186 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,74,self._ctx) + if la_ == 1: + self.state = 1183 + self.identifier() + self.state = 1184 + self.match(PLpgSQLParser.DOT) + + + self.state = 1188 + self.identifier() + pass + + elif la_ == 2: + self.state = 1189 + self.match(PLpgSQLParser.ALL) + pass + + elif la_ == 3: + self.state = 1190 + self.match(PLpgSQLParser.TIME) + self.state = 1191 + self.match(PLpgSQLParser.ZONE) + pass + + elif la_ == 4: + self.state = 1192 + self.match(PLpgSQLParser.TRANSACTION) + self.state = 1193 + self.match(PLpgSQLParser.ISOLATION) + self.state = 1194 + self.match(PLpgSQLParser.LEVEL) + pass + + elif la_ == 5: + self.state = 1195 + self.match(PLpgSQLParser.SESSION) + self.state = 1196 + self.match(PLpgSQLParser.AUTHORIZATION) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Explain_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ANALYZE(self): + return self.getToken(PLpgSQLParser.ANALYZE, 0) + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def COSTS(self): + return self.getToken(PLpgSQLParser.COSTS, 0) + + def SETTINGS(self): + return self.getToken(PLpgSQLParser.SETTINGS, 0) + + def BUFFERS(self): + return self.getToken(PLpgSQLParser.BUFFERS, 0) + + def TIMING(self): + return self.getToken(PLpgSQLParser.TIMING, 0) + + def SUMMARY(self): + return self.getToken(PLpgSQLParser.SUMMARY, 0) + + def boolean_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Boolean_valueContext,0) + + + def FORMAT(self): + return self.getToken(PLpgSQLParser.FORMAT, 0) + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def XML(self): + return self.getToken(PLpgSQLParser.XML, 0) + + def JSON(self): + return self.getToken(PLpgSQLParser.JSON, 0) + + def YAML(self): + return self.getToken(PLpgSQLParser.YAML, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_explain_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExplain_option" ): + listener.enterExplain_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExplain_option" ): + listener.exitExplain_option(self) + + + + + def explain_option(self): + + localctx = PLpgSQLParser.Explain_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_explain_option) + self._la = 0 # Token type + try: + self.state = 1205 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VERBOSE, PLpgSQLParser.ANALYZE, PLpgSQLParser.BUFFERS, PLpgSQLParser.COSTS, PLpgSQLParser.SETTINGS, PLpgSQLParser.SUMMARY, PLpgSQLParser.TIMING]: + self.enterOuterAlt(localctx, 1) + self.state = 1199 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.VERBOSE or _la==PLpgSQLParser.ANALYZE or _la==PLpgSQLParser.BUFFERS or _la==PLpgSQLParser.COSTS or ((((_la - 523)) & ~0x3f) == 0 and ((1 << (_la - 523)) & ((1 << (PLpgSQLParser.SETTINGS - 523)) | (1 << (PLpgSQLParser.SUMMARY - 523)) | (1 << (PLpgSQLParser.TIMING - 523)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1201 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OFF or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0) or _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 1200 + self.boolean_value() + + + pass + elif token in [PLpgSQLParser.FORMAT]: + self.enterOuterAlt(localctx, 2) + self.state = 1203 + self.match(PLpgSQLParser.FORMAT) + self.state = 1204 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TEXT or _la==PLpgSQLParser.XML or _la==PLpgSQLParser.JSON or _la==PLpgSQLParser.YAML): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_nameContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def CURRENT_USER(self): + return self.getToken(PLpgSQLParser.CURRENT_USER, 0) + + def SESSION_USER(self): + return self.getToken(PLpgSQLParser.SESSION_USER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_name" ): + listener.enterUser_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_name" ): + listener.exitUser_name(self) + + + + + def user_name(self): + + localctx = PLpgSQLParser.User_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_user_name) + try: + self.state = 1210 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 1) + self.state = 1207 + self.identifier() + pass + elif token in [PLpgSQLParser.CURRENT_USER]: + self.enterOuterAlt(localctx, 2) + self.state = 1208 + self.match(PLpgSQLParser.CURRENT_USER) + pass + elif token in [PLpgSQLParser.SESSION_USER]: + self.enterOuterAlt(localctx, 3) + self.state = 1209 + self.match(PLpgSQLParser.SESSION_USER) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_cols_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def table_cols(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_colsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_colsContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_cols_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_cols_list" ): + listener.enterTable_cols_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_cols_list" ): + listener.exitTable_cols_list(self) + + + + + def table_cols_list(self): + + localctx = PLpgSQLParser.Table_cols_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_table_cols_list) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1212 + self.table_cols() + self.state = 1217 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1213 + self.match(PLpgSQLParser.COMMA) + self.state = 1214 + self.table_cols() + self.state = 1219 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_colsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_cols + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_cols" ): + listener.enterTable_cols(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_cols" ): + listener.exitTable_cols(self) + + + + + def table_cols(self): + + localctx = PLpgSQLParser.Table_colsContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_table_cols) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1220 + self.schema_qualified_name() + self.state = 1232 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 1221 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1222 + self.identifier() + self.state = 1227 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1223 + self.match(PLpgSQLParser.COMMA) + self.state = 1224 + self.identifier() + self.state = 1229 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1230 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Vacuum_modeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vacuum_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Vacuum_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Vacuum_optionContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def FULL(self): + return self.getToken(PLpgSQLParser.FULL, 0) + + def FREEZE(self): + return self.getToken(PLpgSQLParser.FREEZE, 0) + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def ANALYZE(self): + return self.getToken(PLpgSQLParser.ANALYZE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_vacuum_mode + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVacuum_mode" ): + listener.enterVacuum_mode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVacuum_mode" ): + listener.exitVacuum_mode(self) + + + + + def vacuum_mode(self): + + localctx = PLpgSQLParser.Vacuum_modeContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_vacuum_mode) + self._la = 0 # Token type + try: + self.state = 1257 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 1) + self.state = 1234 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1235 + self.vacuum_option() + self.state = 1240 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1236 + self.match(PLpgSQLParser.COMMA) + self.state = 1237 + self.vacuum_option() + self.state = 1242 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1243 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.VERBOSE, PLpgSQLParser.ANALYZE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.SEMI_COLON, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 2) + self.state = 1246 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FULL: + self.state = 1245 + self.match(PLpgSQLParser.FULL) + + + self.state = 1249 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FREEZE: + self.state = 1248 + self.match(PLpgSQLParser.FREEZE) + + + self.state = 1252 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERBOSE: + self.state = 1251 + self.match(PLpgSQLParser.VERBOSE) + + + self.state = 1255 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ANALYZE: + self.state = 1254 + self.match(PLpgSQLParser.ANALYZE) + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Vacuum_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FULL(self): + return self.getToken(PLpgSQLParser.FULL, 0) + + def FREEZE(self): + return self.getToken(PLpgSQLParser.FREEZE, 0) + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def ANALYZE(self): + return self.getToken(PLpgSQLParser.ANALYZE, 0) + + def DISABLE_PAGE_SKIPPING(self): + return self.getToken(PLpgSQLParser.DISABLE_PAGE_SKIPPING, 0) + + def SKIP_LOCKED(self): + return self.getToken(PLpgSQLParser.SKIP_LOCKED, 0) + + def INDEX_CLEANUP(self): + return self.getToken(PLpgSQLParser.INDEX_CLEANUP, 0) + + def TRUNCATE(self): + return self.getToken(PLpgSQLParser.TRUNCATE, 0) + + def boolean_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Boolean_valueContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_vacuum_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVacuum_option" ): + listener.enterVacuum_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVacuum_option" ): + listener.exitVacuum_option(self) + + + + + def vacuum_option(self): + + localctx = PLpgSQLParser.Vacuum_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 50, self.RULE_vacuum_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1259 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TRUNCATE or ((((_la - 349)) & ~0x3f) == 0 and ((1 << (_la - 349)) & ((1 << (PLpgSQLParser.FREEZE - 349)) | (1 << (PLpgSQLParser.FULL - 349)) | (1 << (PLpgSQLParser.VERBOSE - 349)) | (1 << (PLpgSQLParser.ANALYZE - 349)))) != 0) or _la==PLpgSQLParser.DISABLE_PAGE_SKIPPING or _la==PLpgSQLParser.INDEX_CLEANUP or _la==PLpgSQLParser.SKIP_LOCKED): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1261 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OFF or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0) or _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 1260 + self.boolean_value() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Analyze_modeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def SKIP_LOCKED(self): + return self.getToken(PLpgSQLParser.SKIP_LOCKED, 0) + + def boolean_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Boolean_valueContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_analyze_mode + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAnalyze_mode" ): + listener.enterAnalyze_mode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAnalyze_mode" ): + listener.exitAnalyze_mode(self) + + + + + def analyze_mode(self): + + localctx = PLpgSQLParser.Analyze_modeContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_analyze_mode) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1263 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.VERBOSE or _la==PLpgSQLParser.SKIP_LOCKED): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1265 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OFF or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0) or _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 1264 + self.boolean_value() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Boolean_valueContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRUE(self): + return self.getToken(PLpgSQLParser.TRUE, 0) + + def FALSE(self): + return self.getToken(PLpgSQLParser.FALSE, 0) + + def OFF(self): + return self.getToken(PLpgSQLParser.OFF, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_boolean_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBoolean_value" ): + listener.enterBoolean_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBoolean_value" ): + listener.exitBoolean_value(self) + + + + + def boolean_value(self): + + localctx = PLpgSQLParser.Boolean_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_boolean_value) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1267 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.OFF or ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0) or _la==PLpgSQLParser.NUMBER_LITERAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Fetch_move_directionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NEXT(self): + return self.getToken(PLpgSQLParser.NEXT, 0) + + def PRIOR(self): + return self.getToken(PLpgSQLParser.PRIOR, 0) + + def FIRST(self): + return self.getToken(PLpgSQLParser.FIRST, 0) + + def LAST(self): + return self.getToken(PLpgSQLParser.LAST, 0) + + def signed_number_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Signed_number_literalContext,0) + + + def ABSOLUTE(self): + return self.getToken(PLpgSQLParser.ABSOLUTE, 0) + + def RELATIVE(self): + return self.getToken(PLpgSQLParser.RELATIVE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def FORWARD(self): + return self.getToken(PLpgSQLParser.FORWARD, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def BACKWARD(self): + return self.getToken(PLpgSQLParser.BACKWARD, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_fetch_move_direction + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFetch_move_direction" ): + listener.enterFetch_move_direction(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFetch_move_direction" ): + listener.exitFetch_move_direction(self) + + + + + def fetch_move_direction(self): + + localctx = PLpgSQLParser.Fetch_move_directionContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_fetch_move_direction) + self._la = 0 # Token type + try: + self.state = 1286 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.NEXT]: + self.enterOuterAlt(localctx, 1) + self.state = 1269 + self.match(PLpgSQLParser.NEXT) + pass + elif token in [PLpgSQLParser.PRIOR]: + self.enterOuterAlt(localctx, 2) + self.state = 1270 + self.match(PLpgSQLParser.PRIOR) + pass + elif token in [PLpgSQLParser.FIRST]: + self.enterOuterAlt(localctx, 3) + self.state = 1271 + self.match(PLpgSQLParser.FIRST) + pass + elif token in [PLpgSQLParser.LAST]: + self.enterOuterAlt(localctx, 4) + self.state = 1272 + self.match(PLpgSQLParser.LAST) + pass + elif token in [PLpgSQLParser.ABSOLUTE, PLpgSQLParser.RELATIVE, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.NUMBER_LITERAL]: + self.enterOuterAlt(localctx, 5) + self.state = 1274 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ABSOLUTE or _la==PLpgSQLParser.RELATIVE: + self.state = 1273 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ABSOLUTE or _la==PLpgSQLParser.RELATIVE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1276 + self.signed_number_literal() + pass + elif token in [PLpgSQLParser.ALL]: + self.enterOuterAlt(localctx, 6) + self.state = 1277 + self.match(PLpgSQLParser.ALL) + pass + elif token in [PLpgSQLParser.FORWARD]: + self.enterOuterAlt(localctx, 7) + self.state = 1278 + self.match(PLpgSQLParser.FORWARD) + self.state = 1280 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALL or _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 1279 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALL or _la==PLpgSQLParser.NUMBER_LITERAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + pass + elif token in [PLpgSQLParser.BACKWARD]: + self.enterOuterAlt(localctx, 8) + self.state = 1282 + self.match(PLpgSQLParser.BACKWARD) + self.state = 1284 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALL or _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 1283 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALL or _la==PLpgSQLParser.NUMBER_LITERAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_create(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_createContext,0) + + + def schema_alter(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_alterContext,0) + + + def schema_drop(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_dropContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_statement" ): + listener.enterSchema_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_statement" ): + listener.exitSchema_statement(self) + + + + + def schema_statement(self): + + localctx = PLpgSQLParser.Schema_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_schema_statement) + try: + self.state = 1291 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.COMMENT, PLpgSQLParser.IMPORT, PLpgSQLParser.REVOKE, PLpgSQLParser.SECURITY, PLpgSQLParser.SET, PLpgSQLParser.CREATE, PLpgSQLParser.GRANT]: + self.enterOuterAlt(localctx, 1) + self.state = 1288 + self.schema_create() + pass + elif token in [PLpgSQLParser.ALTER]: + self.enterOuterAlt(localctx, 2) + self.state = 1289 + self.schema_alter() + pass + elif token in [PLpgSQLParser.DROP]: + self.enterOuterAlt(localctx, 3) + self.state = 1290 + self.schema_drop() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_createContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(PLpgSQLParser.CREATE, 0) + + def create_table_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_table_statementContext,0) + + + def create_foreign_table_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_foreign_table_statementContext,0) + + + def create_index_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_index_statementContext,0) + + + def create_extension_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_extension_statementContext,0) + + + def create_trigger_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_trigger_statementContext,0) + + + def create_rewrite_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_rewrite_statementContext,0) + + + def create_function_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_function_statementContext,0) + + + def create_sequence_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_sequence_statementContext,0) + + + def create_schema_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_schema_statementContext,0) + + + def create_view_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_view_statementContext,0) + + + def create_language_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_language_statementContext,0) + + + def create_event_trigger(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_event_triggerContext,0) + + + def create_type_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_type_statementContext,0) + + + def create_domain_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_domain_statementContext,0) + + + def create_server_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_server_statementContext,0) + + + def create_fts_configuration(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_fts_configurationContext,0) + + + def create_fts_template(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_fts_templateContext,0) + + + def create_fts_parser(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_fts_parserContext,0) + + + def create_fts_dictionary(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_fts_dictionaryContext,0) + + + def create_collation(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_collationContext,0) + + + def create_user_mapping(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_user_mappingContext,0) + + + def create_transform_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_transform_statementContext,0) + + + def create_access_method(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_access_methodContext,0) + + + def create_user_or_role(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_user_or_roleContext,0) + + + def create_group(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_groupContext,0) + + + def create_tablespace(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_tablespaceContext,0) + + + def create_statistics(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_statisticsContext,0) + + + def create_foreign_data_wrapper(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_foreign_data_wrapperContext,0) + + + def create_operator_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_operator_statementContext,0) + + + def create_aggregate_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_aggregate_statementContext,0) + + + def create_table_as_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_table_as_statementContext,0) + + + def create_policy_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_policy_statementContext,0) + + + def create_subscription_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_subscription_statementContext,0) + + + def create_cast_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_cast_statementContext,0) + + + def create_operator_family_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_operator_family_statementContext,0) + + + def create_operator_class_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_operator_class_statementContext,0) + + + def create_conversion_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_conversion_statementContext,0) + + + def create_publication_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_publication_statementContext,0) + + + def comment_on_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Comment_on_statementContext,0) + + + def rule_common(self): + return self.getTypedRuleContext(PLpgSQLParser.Rule_commonContext,0) + + + def set_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_statementContext,0) + + + def schema_import(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_importContext,0) + + + def security_label(self): + return self.getTypedRuleContext(PLpgSQLParser.Security_labelContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_create + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_create" ): + listener.enterSchema_create(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_create" ): + listener.exitSchema_create(self) + + + + + def schema_create(self): + + localctx = PLpgSQLParser.Schema_createContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_schema_create) + try: + self.state = 1339 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CREATE]: + self.enterOuterAlt(localctx, 1) + self.state = 1293 + self.match(PLpgSQLParser.CREATE) + self.state = 1332 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,95,self._ctx) + if la_ == 1: + self.state = 1294 + self.create_table_statement() + pass + + elif la_ == 2: + self.state = 1295 + self.create_foreign_table_statement() + pass + + elif la_ == 3: + self.state = 1296 + self.create_index_statement() + pass + + elif la_ == 4: + self.state = 1297 + self.create_extension_statement() + pass + + elif la_ == 5: + self.state = 1298 + self.create_trigger_statement() + pass + + elif la_ == 6: + self.state = 1299 + self.create_rewrite_statement() + pass + + elif la_ == 7: + self.state = 1300 + self.create_function_statement() + pass + + elif la_ == 8: + self.state = 1301 + self.create_sequence_statement() + pass + + elif la_ == 9: + self.state = 1302 + self.create_schema_statement() + pass + + elif la_ == 10: + self.state = 1303 + self.create_view_statement() + pass + + elif la_ == 11: + self.state = 1304 + self.create_language_statement() + pass + + elif la_ == 12: + self.state = 1305 + self.create_event_trigger() + pass + + elif la_ == 13: + self.state = 1306 + self.create_type_statement() + pass + + elif la_ == 14: + self.state = 1307 + self.create_domain_statement() + pass + + elif la_ == 15: + self.state = 1308 + self.create_server_statement() + pass + + elif la_ == 16: + self.state = 1309 + self.create_fts_configuration() + pass + + elif la_ == 17: + self.state = 1310 + self.create_fts_template() + pass + + elif la_ == 18: + self.state = 1311 + self.create_fts_parser() + pass + + elif la_ == 19: + self.state = 1312 + self.create_fts_dictionary() + pass + + elif la_ == 20: + self.state = 1313 + self.create_collation() + pass + + elif la_ == 21: + self.state = 1314 + self.create_user_mapping() + pass + + elif la_ == 22: + self.state = 1315 + self.create_transform_statement() + pass + + elif la_ == 23: + self.state = 1316 + self.create_access_method() + pass + + elif la_ == 24: + self.state = 1317 + self.create_user_or_role() + pass + + elif la_ == 25: + self.state = 1318 + self.create_group() + pass + + elif la_ == 26: + self.state = 1319 + self.create_tablespace() + pass + + elif la_ == 27: + self.state = 1320 + self.create_statistics() + pass + + elif la_ == 28: + self.state = 1321 + self.create_foreign_data_wrapper() + pass + + elif la_ == 29: + self.state = 1322 + self.create_operator_statement() + pass + + elif la_ == 30: + self.state = 1323 + self.create_aggregate_statement() + pass + + elif la_ == 31: + self.state = 1324 + self.create_table_as_statement() + pass + + elif la_ == 32: + self.state = 1325 + self.create_policy_statement() + pass + + elif la_ == 33: + self.state = 1326 + self.create_subscription_statement() + pass + + elif la_ == 34: + self.state = 1327 + self.create_cast_statement() + pass + + elif la_ == 35: + self.state = 1328 + self.create_operator_family_statement() + pass + + elif la_ == 36: + self.state = 1329 + self.create_operator_class_statement() + pass + + elif la_ == 37: + self.state = 1330 + self.create_conversion_statement() + pass + + elif la_ == 38: + self.state = 1331 + self.create_publication_statement() + pass + + + pass + elif token in [PLpgSQLParser.COMMENT]: + self.enterOuterAlt(localctx, 2) + self.state = 1334 + self.comment_on_statement() + pass + elif token in [PLpgSQLParser.REVOKE, PLpgSQLParser.GRANT]: + self.enterOuterAlt(localctx, 3) + self.state = 1335 + self.rule_common() + pass + elif token in [PLpgSQLParser.SET]: + self.enterOuterAlt(localctx, 4) + self.state = 1336 + self.set_statement() + pass + elif token in [PLpgSQLParser.IMPORT]: + self.enterOuterAlt(localctx, 5) + self.state = 1337 + self.schema_import() + pass + elif token in [PLpgSQLParser.SECURITY]: + self.enterOuterAlt(localctx, 6) + self.state = 1338 + self.security_label() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_alterContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def alter_function_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_function_statementContext,0) + + + def alter_schema_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_schema_statementContext,0) + + + def alter_language_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_language_statementContext,0) + + + def alter_table_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_table_statementContext,0) + + + def alter_index_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_index_statementContext,0) + + + def alter_default_privileges(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_default_privilegesContext,0) + + + def alter_sequence_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_sequence_statementContext,0) + + + def alter_view_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_view_statementContext,0) + + + def alter_event_trigger(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_event_triggerContext,0) + + + def alter_type_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_type_statementContext,0) + + + def alter_domain_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_domain_statementContext,0) + + + def alter_server_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_server_statementContext,0) + + + def alter_fts_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_fts_statementContext,0) + + + def alter_collation(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_collationContext,0) + + + def alter_user_mapping(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_user_mappingContext,0) + + + def alter_user_or_role(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_user_or_roleContext,0) + + + def alter_group(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_groupContext,0) + + + def alter_tablespace(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_tablespaceContext,0) + + + def alter_statistics(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_statisticsContext,0) + + + def alter_foreign_data_wrapper(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_foreign_data_wrapperContext,0) + + + def alter_operator_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_operator_statementContext,0) + + + def alter_aggregate_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_aggregate_statementContext,0) + + + def alter_extension_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_extension_statementContext,0) + + + def alter_policy_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_policy_statementContext,0) + + + def alter_subscription_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_subscription_statementContext,0) + + + def alter_trigger_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_trigger_statementContext,0) + + + def alter_rule_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_rule_statementContext,0) + + + def alter_operator_family_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_operator_family_statementContext,0) + + + def alter_operator_class_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_operator_class_statementContext,0) + + + def alter_conversion_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_conversion_statementContext,0) + + + def alter_publication_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_publication_statementContext,0) + + + def alter_owner(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_ownerContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_alter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_alter" ): + listener.enterSchema_alter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_alter" ): + listener.exitSchema_alter(self) + + + + + def schema_alter(self): + + localctx = PLpgSQLParser.Schema_alterContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_schema_alter) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1341 + self.match(PLpgSQLParser.ALTER) + self.state = 1374 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,97,self._ctx) + if la_ == 1: + self.state = 1342 + self.alter_function_statement() + pass + + elif la_ == 2: + self.state = 1343 + self.alter_schema_statement() + pass + + elif la_ == 3: + self.state = 1344 + self.alter_language_statement() + pass + + elif la_ == 4: + self.state = 1345 + self.alter_table_statement() + pass + + elif la_ == 5: + self.state = 1346 + self.alter_index_statement() + pass + + elif la_ == 6: + self.state = 1347 + self.alter_default_privileges() + pass + + elif la_ == 7: + self.state = 1348 + self.alter_sequence_statement() + pass + + elif la_ == 8: + self.state = 1349 + self.alter_view_statement() + pass + + elif la_ == 9: + self.state = 1350 + self.alter_event_trigger() + pass + + elif la_ == 10: + self.state = 1351 + self.alter_type_statement() + pass + + elif la_ == 11: + self.state = 1352 + self.alter_domain_statement() + pass + + elif la_ == 12: + self.state = 1353 + self.alter_server_statement() + pass + + elif la_ == 13: + self.state = 1354 + self.alter_fts_statement() + pass + + elif la_ == 14: + self.state = 1355 + self.alter_collation() + pass + + elif la_ == 15: + self.state = 1356 + self.alter_user_mapping() + pass + + elif la_ == 16: + self.state = 1357 + self.alter_user_or_role() + pass + + elif la_ == 17: + self.state = 1358 + self.alter_group() + pass + + elif la_ == 18: + self.state = 1359 + self.alter_tablespace() + pass + + elif la_ == 19: + self.state = 1360 + self.alter_statistics() + pass + + elif la_ == 20: + self.state = 1361 + self.alter_foreign_data_wrapper() + pass + + elif la_ == 21: + self.state = 1362 + self.alter_operator_statement() + pass + + elif la_ == 22: + self.state = 1363 + self.alter_aggregate_statement() + pass + + elif la_ == 23: + self.state = 1364 + self.alter_extension_statement() + pass + + elif la_ == 24: + self.state = 1365 + self.alter_policy_statement() + pass + + elif la_ == 25: + self.state = 1366 + self.alter_subscription_statement() + pass + + elif la_ == 26: + self.state = 1367 + self.alter_trigger_statement() + pass + + elif la_ == 27: + self.state = 1368 + self.alter_rule_statement() + pass + + elif la_ == 28: + self.state = 1369 + self.alter_operator_family_statement() + pass + + elif la_ == 29: + self.state = 1370 + self.alter_operator_class_statement() + pass + + elif la_ == 30: + self.state = 1371 + self.alter_conversion_statement() + pass + + elif la_ == 31: + self.state = 1372 + self.alter_publication_statement() + pass + + elif la_ == 32: + self.state = 1373 + self.alter_owner() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_dropContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def drop_function_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_function_statementContext,0) + + + def drop_trigger_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_trigger_statementContext,0) + + + def drop_rule_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_rule_statementContext,0) + + + def drop_policy_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_policy_statementContext,0) + + + def drop_cast_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_cast_statementContext,0) + + + def drop_operator_family_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_operator_family_statementContext,0) + + + def drop_operator_class_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_operator_class_statementContext,0) + + + def drop_statements(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_statementsContext,0) + + + def drop_user_mapping(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_user_mappingContext,0) + + + def drop_owned(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_ownedContext,0) + + + def drop_operator_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_operator_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_drop + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_drop" ): + listener.enterSchema_drop(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_drop" ): + listener.exitSchema_drop(self) + + + + + def schema_drop(self): + + localctx = PLpgSQLParser.Schema_dropContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_schema_drop) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1376 + self.match(PLpgSQLParser.DROP) + self.state = 1388 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,98,self._ctx) + if la_ == 1: + self.state = 1377 + self.drop_function_statement() + pass + + elif la_ == 2: + self.state = 1378 + self.drop_trigger_statement() + pass + + elif la_ == 3: + self.state = 1379 + self.drop_rule_statement() + pass + + elif la_ == 4: + self.state = 1380 + self.drop_policy_statement() + pass + + elif la_ == 5: + self.state = 1381 + self.drop_cast_statement() + pass + + elif la_ == 6: + self.state = 1382 + self.drop_operator_family_statement() + pass + + elif la_ == 7: + self.state = 1383 + self.drop_operator_class_statement() + pass + + elif la_ == 8: + self.state = 1384 + self.drop_statements() + pass + + elif la_ == 9: + self.state = 1385 + self.drop_user_mapping() + pass + + elif la_ == 10: + self.state = 1386 + self.drop_owned() + pass + + elif la_ == 11: + self.state = 1387 + self.drop_operator_statement() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_importContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def IMPORT(self): + return self.getToken(PLpgSQLParser.IMPORT, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def INTO(self): + return self.getToken(PLpgSQLParser.INTO, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def LIMIT(self): + return self.getToken(PLpgSQLParser.LIMIT, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def EXCEPT(self): + return self.getToken(PLpgSQLParser.EXCEPT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_import + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_import" ): + listener.enterSchema_import(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_import" ): + listener.exitSchema_import(self) + + + + + def schema_import(self): + + localctx = PLpgSQLParser.Schema_importContext(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_schema_import) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1390 + self.match(PLpgSQLParser.IMPORT) + self.state = 1391 + self.match(PLpgSQLParser.FOREIGN) + self.state = 1392 + self.match(PLpgSQLParser.SCHEMA) + self.state = 1393 + localctx.name = self.identifier() + self.state = 1403 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.EXCEPT or _la==PLpgSQLParser.LIMIT: + self.state = 1397 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LIMIT]: + self.state = 1394 + self.match(PLpgSQLParser.LIMIT) + self.state = 1395 + self.match(PLpgSQLParser.TO) + pass + elif token in [PLpgSQLParser.EXCEPT]: + self.state = 1396 + self.match(PLpgSQLParser.EXCEPT) + pass + else: + raise NoViableAltException(self) + + self.state = 1399 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1400 + self.identifier_list() + self.state = 1401 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 1405 + self.match(PLpgSQLParser.FROM) + self.state = 1406 + self.match(PLpgSQLParser.SERVER) + self.state = 1407 + self.identifier() + self.state = 1408 + self.match(PLpgSQLParser.INTO) + self.state = 1409 + self.identifier() + self.state = 1411 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 1410 + self.define_foreign_options() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_function_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def DEPENDS(self): + return self.getToken(PLpgSQLParser.DEPENDS, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def function_parameters(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_parametersContext,0) + + + def function_actions_common(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_actions_commonContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_actions_commonContext,i) + + + def RESET(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RESET) + else: + return self.getToken(PLpgSQLParser.RESET, i) + + def RESTRICT(self): + return self.getToken(PLpgSQLParser.RESTRICT, 0) + + def ALL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ALL) + else: + return self.getToken(PLpgSQLParser.ALL, i) + + def DOT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DOT) + else: + return self.getToken(PLpgSQLParser.DOT, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_function_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_function_statement" ): + listener.enterAlter_function_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_function_statement" ): + listener.exitAlter_function_statement(self) + + + + + def alter_function_statement(self): + + localctx = PLpgSQLParser.Alter_function_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_alter_function_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1413 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1415 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,102,self._ctx) + if la_ == 1: + self.state = 1414 + self.function_parameters() + + + self.state = 1441 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,108,self._ctx) + if la_ == 1: + self.state = 1428 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1428 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CALLED, PLpgSQLParser.COST, PLpgSQLParser.EXTERNAL, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.PARALLEL, PLpgSQLParser.RETURNS, PLpgSQLParser.ROWS, PLpgSQLParser.SECURITY, PLpgSQLParser.SET, PLpgSQLParser.STABLE, PLpgSQLParser.STRICT, PLpgSQLParser.SUPPORT, PLpgSQLParser.TRANSFORM, PLpgSQLParser.VOLATILE, PLpgSQLParser.AS, PLpgSQLParser.NOT, PLpgSQLParser.WINDOW]: + self.state = 1417 + self.function_actions_common() + pass + elif token in [PLpgSQLParser.RESET]: + self.state = 1418 + self.match(PLpgSQLParser.RESET) + self.state = 1426 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 1422 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,103,self._ctx) + if la_ == 1: + self.state = 1419 + self.identifier() + self.state = 1420 + self.match(PLpgSQLParser.DOT) + + + self.state = 1424 + self.identifier() + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 1425 + self.match(PLpgSQLParser.ALL) + pass + else: + raise NoViableAltException(self) + + pass + else: + raise NoViableAltException(self) + + self.state = 1430 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.CALLED or _la==PLpgSQLParser.COST or ((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (PLpgSQLParser.EXTERNAL - 85)) | (1 << (PLpgSQLParser.IMMUTABLE - 85)) | (1 << (PLpgSQLParser.LANGUAGE - 85)) | (1 << (PLpgSQLParser.LEAKPROOF - 85)))) != 0) or ((((_la - 169)) & ~0x3f) == 0 and ((1 << (_la - 169)) & ((1 << (PLpgSQLParser.PARALLEL - 169)) | (1 << (PLpgSQLParser.RESET - 169)) | (1 << (PLpgSQLParser.RETURNS - 169)) | (1 << (PLpgSQLParser.ROWS - 169)) | (1 << (PLpgSQLParser.SECURITY - 169)) | (1 << (PLpgSQLParser.SET - 169)))) != 0) or ((((_la - 236)) & ~0x3f) == 0 and ((1 << (_la - 236)) & ((1 << (PLpgSQLParser.STABLE - 236)) | (1 << (PLpgSQLParser.STRICT - 236)) | (1 << (PLpgSQLParser.SUPPORT - 236)) | (1 << (PLpgSQLParser.TRANSFORM - 236)) | (1 << (PLpgSQLParser.VOLATILE - 236)))) != 0) or _la==PLpgSQLParser.AS or _la==PLpgSQLParser.NOT or _la==PLpgSQLParser.WINDOW): + break + + self.state = 1433 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.RESTRICT: + self.state = 1432 + self.match(PLpgSQLParser.RESTRICT) + + + pass + + elif la_ == 2: + self.state = 1435 + self.rename_to() + pass + + elif la_ == 3: + self.state = 1436 + self.set_schema() + pass + + elif la_ == 4: + self.state = 1437 + self.match(PLpgSQLParser.DEPENDS) + self.state = 1438 + self.match(PLpgSQLParser.ON) + self.state = 1439 + self.match(PLpgSQLParser.EXTENSION) + self.state = 1440 + self.identifier() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_aggregate_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def function_parameters(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_parametersContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_aggregate_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_aggregate_statement" ): + listener.enterAlter_aggregate_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_aggregate_statement" ): + listener.exitAlter_aggregate_statement(self) + + + + + def alter_aggregate_statement(self): + + localctx = PLpgSQLParser.Alter_aggregate_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_alter_aggregate_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1443 + self.match(PLpgSQLParser.AGGREGATE) + self.state = 1444 + self.function_parameters() + self.state = 1447 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 1445 + self.rename_to() + pass + elif token in [PLpgSQLParser.SET]: + self.state = 1446 + self.set_schema() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_extension_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def alter_extension_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_extension_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_extension_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_extension_statement" ): + listener.enterAlter_extension_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_extension_statement" ): + listener.exitAlter_extension_statement(self) + + + + + def alter_extension_statement(self): + + localctx = PLpgSQLParser.Alter_extension_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_alter_extension_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1449 + self.match(PLpgSQLParser.EXTENSION) + self.state = 1450 + self.identifier() + self.state = 1451 + self.alter_extension_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_extension_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def extension_member_object(self): + return self.getTypedRuleContext(PLpgSQLParser.Extension_member_objectContext,0) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_extension_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_extension_action" ): + listener.enterAlter_extension_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_extension_action" ): + listener.exitAlter_extension_action(self) + + + + + def alter_extension_action(self): + + localctx = PLpgSQLParser.Alter_extension_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_alter_extension_action) + self._la = 0 # Token type + try: + self.state = 1464 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SET]: + self.enterOuterAlt(localctx, 1) + self.state = 1453 + self.set_schema() + pass + elif token in [PLpgSQLParser.UPDATE]: + self.enterOuterAlt(localctx, 2) + self.state = 1454 + self.match(PLpgSQLParser.UPDATE) + self.state = 1460 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TO: + self.state = 1455 + self.match(PLpgSQLParser.TO) + self.state = 1458 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 1456 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 1457 + self.character_string() + pass + else: + raise NoViableAltException(self) + + + + pass + elif token in [PLpgSQLParser.ADD, PLpgSQLParser.DROP]: + self.enterOuterAlt(localctx, 3) + self.state = 1462 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ADD or _la==PLpgSQLParser.DROP): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1463 + self.extension_member_object() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Extension_member_objectContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ACCESS(self): + return self.getToken(PLpgSQLParser.ACCESS, 0) + + def METHOD(self): + return self.getToken(PLpgSQLParser.METHOD, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def function_parameters(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_parametersContext,0) + + + def CAST(self): + return self.getToken(PLpgSQLParser.CAST, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def CONVERSION(self): + return self.getToken(PLpgSQLParser.CONVERSION, 0) + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def operator_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Operator_nameContext,0) + + + def CLASS(self): + return self.getToken(PLpgSQLParser.CLASS, 0) + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def ROUTINE(self): + return self.getToken(PLpgSQLParser.ROUTINE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def TRANSFORM(self): + return self.getToken(PLpgSQLParser.TRANSFORM, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_extension_member_object + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExtension_member_object" ): + listener.enterExtension_member_object(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExtension_member_object" ): + listener.exitExtension_member_object(self) + + + + + def extension_member_object(self): + + localctx = PLpgSQLParser.Extension_member_objectContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_extension_member_object) + self._la = 0 # Token type + try: + self.state = 1556 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,115,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1466 + self.match(PLpgSQLParser.ACCESS) + self.state = 1467 + self.match(PLpgSQLParser.METHOD) + self.state = 1468 + self.schema_qualified_name() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1469 + self.match(PLpgSQLParser.AGGREGATE) + self.state = 1470 + self.function_parameters() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1471 + self.match(PLpgSQLParser.CAST) + self.state = 1472 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1473 + self.schema_qualified_name() + self.state = 1474 + self.match(PLpgSQLParser.AS) + self.state = 1475 + self.schema_qualified_name() + self.state = 1476 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1478 + self.match(PLpgSQLParser.COLLATION) + self.state = 1479 + self.identifier() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1480 + self.match(PLpgSQLParser.CONVERSION) + self.state = 1481 + self.identifier() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1482 + self.match(PLpgSQLParser.DOMAIN) + self.state = 1483 + self.schema_qualified_name() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1484 + self.match(PLpgSQLParser.EVENT) + self.state = 1485 + self.match(PLpgSQLParser.TRIGGER) + self.state = 1486 + self.identifier() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 1487 + self.match(PLpgSQLParser.FOREIGN) + self.state = 1488 + self.match(PLpgSQLParser.DATA) + self.state = 1489 + self.match(PLpgSQLParser.WRAPPER) + self.state = 1490 + self.identifier() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 1491 + self.match(PLpgSQLParser.FOREIGN) + self.state = 1492 + self.match(PLpgSQLParser.TABLE) + self.state = 1493 + self.schema_qualified_name() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 1494 + self.match(PLpgSQLParser.FUNCTION) + self.state = 1495 + self.function_parameters() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 1497 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 1496 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 1499 + self.match(PLpgSQLParser.VIEW) + self.state = 1500 + self.schema_qualified_name() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 1501 + self.match(PLpgSQLParser.OPERATOR) + self.state = 1502 + self.operator_name() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 1503 + self.match(PLpgSQLParser.OPERATOR) + self.state = 1504 + self.match(PLpgSQLParser.CLASS) + self.state = 1505 + self.schema_qualified_name() + self.state = 1506 + self.match(PLpgSQLParser.USING) + self.state = 1507 + self.identifier() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 1509 + self.match(PLpgSQLParser.OPERATOR) + self.state = 1510 + self.match(PLpgSQLParser.FAMILY) + self.state = 1511 + self.schema_qualified_name() + self.state = 1512 + self.match(PLpgSQLParser.USING) + self.state = 1513 + self.identifier() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 1516 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROCEDURAL: + self.state = 1515 + self.match(PLpgSQLParser.PROCEDURAL) + + + self.state = 1518 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 1519 + self.identifier() + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 1520 + self.match(PLpgSQLParser.PROCEDURE) + self.state = 1521 + self.function_parameters() + pass + + elif la_ == 17: + self.enterOuterAlt(localctx, 17) + self.state = 1522 + self.match(PLpgSQLParser.ROUTINE) + self.state = 1523 + self.function_parameters() + pass + + elif la_ == 18: + self.enterOuterAlt(localctx, 18) + self.state = 1524 + self.match(PLpgSQLParser.SCHEMA) + self.state = 1525 + self.identifier() + pass + + elif la_ == 19: + self.enterOuterAlt(localctx, 19) + self.state = 1526 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 1527 + self.schema_qualified_name() + pass + + elif la_ == 20: + self.enterOuterAlt(localctx, 20) + self.state = 1528 + self.match(PLpgSQLParser.SERVER) + self.state = 1529 + self.identifier() + pass + + elif la_ == 21: + self.enterOuterAlt(localctx, 21) + self.state = 1530 + self.match(PLpgSQLParser.TABLE) + self.state = 1531 + self.schema_qualified_name() + pass + + elif la_ == 22: + self.enterOuterAlt(localctx, 22) + self.state = 1532 + self.match(PLpgSQLParser.TEXT) + self.state = 1533 + self.match(PLpgSQLParser.SEARCH) + self.state = 1534 + self.match(PLpgSQLParser.CONFIGURATION) + self.state = 1535 + self.schema_qualified_name() + pass + + elif la_ == 23: + self.enterOuterAlt(localctx, 23) + self.state = 1536 + self.match(PLpgSQLParser.TEXT) + self.state = 1537 + self.match(PLpgSQLParser.SEARCH) + self.state = 1538 + self.match(PLpgSQLParser.DICTIONARY) + self.state = 1539 + self.schema_qualified_name() + pass + + elif la_ == 24: + self.enterOuterAlt(localctx, 24) + self.state = 1540 + self.match(PLpgSQLParser.TEXT) + self.state = 1541 + self.match(PLpgSQLParser.SEARCH) + self.state = 1542 + self.match(PLpgSQLParser.PARSER) + self.state = 1543 + self.schema_qualified_name() + pass + + elif la_ == 25: + self.enterOuterAlt(localctx, 25) + self.state = 1544 + self.match(PLpgSQLParser.TEXT) + self.state = 1545 + self.match(PLpgSQLParser.SEARCH) + self.state = 1546 + self.match(PLpgSQLParser.TEMPLATE) + self.state = 1547 + self.schema_qualified_name() + pass + + elif la_ == 26: + self.enterOuterAlt(localctx, 26) + self.state = 1548 + self.match(PLpgSQLParser.TRANSFORM) + self.state = 1549 + self.match(PLpgSQLParser.FOR) + self.state = 1550 + self.identifier() + self.state = 1551 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 1552 + self.identifier() + pass + + elif la_ == 27: + self.enterOuterAlt(localctx, 27) + self.state = 1554 + self.match(PLpgSQLParser.TYPE) + self.state = 1555 + self.schema_qualified_name() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_schema_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_schema_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_schema_statement" ): + listener.enterAlter_schema_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_schema_statement" ): + listener.exitAlter_schema_statement(self) + + + + + def alter_schema_statement(self): + + localctx = PLpgSQLParser.Alter_schema_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_alter_schema_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1558 + self.match(PLpgSQLParser.SCHEMA) + self.state = 1559 + self.identifier() + self.state = 1560 + self.rename_to() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_language_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_language_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_language_statement" ): + listener.enterAlter_language_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_language_statement" ): + listener.exitAlter_language_statement(self) + + + + + def alter_language_statement(self): + + localctx = PLpgSQLParser.Alter_language_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_alter_language_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1563 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROCEDURAL: + self.state = 1562 + self.match(PLpgSQLParser.PROCEDURAL) + + + self.state = 1565 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 1566 + localctx.name = self.identifier() + self.state = 1569 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 1567 + self.rename_to() + pass + elif token in [PLpgSQLParser.OWNER]: + self.state = 1568 + self.owner_to() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_table_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.child = None # Schema_qualified_nameContext + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def table_action(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_actionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_actionContext,i) + + + def RENAME(self): + return self.getToken(PLpgSQLParser.RENAME, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def ATTACH(self): + return self.getToken(PLpgSQLParser.ATTACH, 0) + + def PARTITION(self): + return self.getToken(PLpgSQLParser.PARTITION, 0) + + def for_values_bound(self): + return self.getTypedRuleContext(PLpgSQLParser.For_values_boundContext,0) + + + def DETACH(self): + return self.getToken(PLpgSQLParser.DETACH, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_table_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_table_statement" ): + listener.enterAlter_table_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_table_statement" ): + listener.exitAlter_table_statement(self) + + + + + def alter_table_statement(self): + + localctx = PLpgSQLParser.Alter_table_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_alter_table_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1572 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOREIGN: + self.state = 1571 + self.match(PLpgSQLParser.FOREIGN) + + + self.state = 1574 + self.match(PLpgSQLParser.TABLE) + self.state = 1576 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,119,self._ctx) + if la_ == 1: + self.state = 1575 + self.if_exists() + + + self.state = 1579 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 1578 + self.match(PLpgSQLParser.ONLY) + + + self.state = 1581 + localctx.name = self.schema_qualified_name() + self.state = 1583 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MULTIPLY: + self.state = 1582 + self.match(PLpgSQLParser.MULTIPLY) + + + self.state = 1617 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,124,self._ctx) + if la_ == 1: + self.state = 1585 + self.table_action() + self.state = 1590 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1586 + self.match(PLpgSQLParser.COMMA) + self.state = 1587 + self.table_action() + self.state = 1592 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 2: + self.state = 1593 + self.match(PLpgSQLParser.RENAME) + self.state = 1595 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLUMN: + self.state = 1594 + self.match(PLpgSQLParser.COLUMN) + + + self.state = 1597 + self.identifier() + self.state = 1598 + self.match(PLpgSQLParser.TO) + self.state = 1599 + self.identifier() + pass + + elif la_ == 3: + self.state = 1601 + self.set_schema() + pass + + elif la_ == 4: + self.state = 1602 + self.rename_to() + pass + + elif la_ == 5: + self.state = 1603 + self.match(PLpgSQLParser.RENAME) + self.state = 1604 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 1605 + self.identifier() + self.state = 1606 + self.match(PLpgSQLParser.TO) + self.state = 1607 + self.identifier() + pass + + elif la_ == 6: + self.state = 1609 + self.match(PLpgSQLParser.ATTACH) + self.state = 1610 + self.match(PLpgSQLParser.PARTITION) + self.state = 1611 + localctx.child = self.schema_qualified_name() + self.state = 1612 + self.for_values_bound() + pass + + elif la_ == 7: + self.state = 1614 + self.match(PLpgSQLParser.DETACH) + self.state = 1615 + self.match(PLpgSQLParser.PARTITION) + self.state = 1616 + localctx.child = self.schema_qualified_name() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.column = None # IdentifierContext + self.tabl_constraint = None # Constraint_commonContext + self.not_valid = None # Token + self.trigger_name = None # Schema_qualified_nameContext + self.rewrite_rule_name = None # Schema_qualified_nameContext + self.index_name = None # Schema_qualified_nameContext + self.parent_table = None # Schema_qualified_nameContext + self.type_name = None # Schema_qualified_nameContext + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def table_column_definition(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_column_definitionContext,0) + + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def column_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Column_actionContext,0) + + + def constraint_common(self): + return self.getTypedRuleContext(PLpgSQLParser.Constraint_commonContext,0) + + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def VALID(self): + return self.getToken(PLpgSQLParser.VALID, 0) + + def validate_constraint(self): + return self.getTypedRuleContext(PLpgSQLParser.Validate_constraintContext,0) + + + def drop_constraint(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_constraintContext,0) + + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def DISABLE(self): + return self.getToken(PLpgSQLParser.DISABLE, 0) + + def ENABLE(self): + return self.getToken(PLpgSQLParser.ENABLE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def REPLICA(self): + return self.getToken(PLpgSQLParser.REPLICA, 0) + + def ALWAYS(self): + return self.getToken(PLpgSQLParser.ALWAYS, 0) + + def RULE(self): + return self.getToken(PLpgSQLParser.RULE, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def LEVEL(self): + return self.getToken(PLpgSQLParser.LEVEL, 0) + + def SECURITY(self): + return self.getToken(PLpgSQLParser.SECURITY, 0) + + def FORCE(self): + return self.getToken(PLpgSQLParser.FORCE, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def CLUSTER(self): + return self.getToken(PLpgSQLParser.CLUSTER, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def WITHOUT(self): + return self.getToken(PLpgSQLParser.WITHOUT, 0) + + def OIDS(self): + return self.getToken(PLpgSQLParser.OIDS, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def LOGGED(self): + return self.getToken(PLpgSQLParser.LOGGED, 0) + + def UNLOGGED(self): + return self.getToken(PLpgSQLParser.UNLOGGED, 0) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def names_in_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,0) + + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def INHERIT(self): + return self.getToken(PLpgSQLParser.INHERIT, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def table_space(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_spaceContext,0) + + + def IDENTITY(self): + return self.getToken(PLpgSQLParser.IDENTITY, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def FULL(self): + return self.getToken(PLpgSQLParser.FULL, 0) + + def NOTHING(self): + return self.getToken(PLpgSQLParser.NOTHING, 0) + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def table_deferrable(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_deferrableContext,0) + + + def table_initialy_immed(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_initialy_immedContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_action" ): + listener.enterTable_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_action" ): + listener.exitTable_action(self) + + + + + def table_action(self): + + localctx = PLpgSQLParser.Table_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_table_action) + self._la = 0 # Token type + try: + self.state = 1729 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,137,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1619 + self.match(PLpgSQLParser.ADD) + self.state = 1621 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLUMN: + self.state = 1620 + self.match(PLpgSQLParser.COLUMN) + + + self.state = 1624 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,126,self._ctx) + if la_ == 1: + self.state = 1623 + self.if_not_exists() + + + self.state = 1626 + self.table_column_definition() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1627 + self.match(PLpgSQLParser.DROP) + self.state = 1629 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLUMN: + self.state = 1628 + self.match(PLpgSQLParser.COLUMN) + + + self.state = 1632 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,128,self._ctx) + if la_ == 1: + self.state = 1631 + self.if_exists() + + + self.state = 1634 + localctx.column = self.identifier() + self.state = 1636 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 1635 + self.cascade_restrict() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1638 + self.match(PLpgSQLParser.ALTER) + self.state = 1640 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLUMN: + self.state = 1639 + self.match(PLpgSQLParser.COLUMN) + + + self.state = 1642 + localctx.column = self.identifier() + self.state = 1643 + self.column_action() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1645 + self.match(PLpgSQLParser.ADD) + self.state = 1646 + localctx.tabl_constraint = self.constraint_common() + self.state = 1649 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 1647 + self.match(PLpgSQLParser.NOT) + self.state = 1648 + localctx.not_valid = self.match(PLpgSQLParser.VALID) + + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1651 + self.validate_constraint() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1652 + self.drop_constraint() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1653 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DISABLE or _la==PLpgSQLParser.ENABLE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1654 + self.match(PLpgSQLParser.TRIGGER) + self.state = 1658 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 1655 + localctx.trigger_name = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 1656 + self.match(PLpgSQLParser.ALL) + pass + elif token in [PLpgSQLParser.USER]: + self.state = 1657 + self.match(PLpgSQLParser.USER) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.SEMI_COLON, PLpgSQLParser.COMMA]: + pass + else: + pass + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 1660 + self.match(PLpgSQLParser.ENABLE) + self.state = 1661 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALWAYS or _la==PLpgSQLParser.REPLICA): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1662 + self.match(PLpgSQLParser.TRIGGER) + self.state = 1663 + localctx.trigger_name = self.schema_qualified_name() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 1664 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DISABLE or _la==PLpgSQLParser.ENABLE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1665 + self.match(PLpgSQLParser.RULE) + self.state = 1666 + localctx.rewrite_rule_name = self.schema_qualified_name() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 1667 + self.match(PLpgSQLParser.ENABLE) + self.state = 1668 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALWAYS or _la==PLpgSQLParser.REPLICA): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1669 + self.match(PLpgSQLParser.RULE) + self.state = 1670 + localctx.rewrite_rule_name = self.schema_qualified_name() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 1671 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DISABLE or _la==PLpgSQLParser.ENABLE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1672 + self.match(PLpgSQLParser.ROW) + self.state = 1673 + self.match(PLpgSQLParser.LEVEL) + self.state = 1674 + self.match(PLpgSQLParser.SECURITY) + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 1676 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 1675 + self.match(PLpgSQLParser.NO) + + + self.state = 1678 + self.match(PLpgSQLParser.FORCE) + self.state = 1679 + self.match(PLpgSQLParser.ROW) + self.state = 1680 + self.match(PLpgSQLParser.LEVEL) + self.state = 1681 + self.match(PLpgSQLParser.SECURITY) + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 1682 + self.match(PLpgSQLParser.CLUSTER) + self.state = 1683 + self.match(PLpgSQLParser.ON) + self.state = 1684 + localctx.index_name = self.schema_qualified_name() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 1685 + self.match(PLpgSQLParser.SET) + self.state = 1686 + self.match(PLpgSQLParser.WITHOUT) + self.state = 1687 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CLUSTER or _la==PLpgSQLParser.OIDS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 1688 + self.match(PLpgSQLParser.SET) + self.state = 1689 + self.match(PLpgSQLParser.WITH) + self.state = 1690 + self.match(PLpgSQLParser.OIDS) + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 1691 + self.match(PLpgSQLParser.SET) + self.state = 1692 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.LOGGED or _la==PLpgSQLParser.UNLOGGED): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 17: + self.enterOuterAlt(localctx, 17) + self.state = 1693 + self.match(PLpgSQLParser.SET) + self.state = 1694 + self.storage_parameter() + pass + + elif la_ == 18: + self.enterOuterAlt(localctx, 18) + self.state = 1695 + self.match(PLpgSQLParser.RESET) + self.state = 1696 + self.names_in_parens() + pass + + elif la_ == 19: + self.enterOuterAlt(localctx, 19) + self.state = 1697 + self.define_foreign_options() + pass + + elif la_ == 20: + self.enterOuterAlt(localctx, 20) + self.state = 1698 + self.match(PLpgSQLParser.INHERIT) + self.state = 1699 + localctx.parent_table = self.schema_qualified_name() + pass + + elif la_ == 21: + self.enterOuterAlt(localctx, 21) + self.state = 1700 + self.match(PLpgSQLParser.NO) + self.state = 1701 + self.match(PLpgSQLParser.INHERIT) + self.state = 1702 + localctx.parent_table = self.schema_qualified_name() + pass + + elif la_ == 22: + self.enterOuterAlt(localctx, 22) + self.state = 1703 + self.match(PLpgSQLParser.OF) + self.state = 1704 + localctx.type_name = self.schema_qualified_name() + pass + + elif la_ == 23: + self.enterOuterAlt(localctx, 23) + self.state = 1705 + self.match(PLpgSQLParser.NOT) + self.state = 1706 + self.match(PLpgSQLParser.OF) + pass + + elif la_ == 24: + self.enterOuterAlt(localctx, 24) + self.state = 1707 + self.owner_to() + pass + + elif la_ == 25: + self.enterOuterAlt(localctx, 25) + self.state = 1708 + self.match(PLpgSQLParser.SET) + self.state = 1709 + self.table_space() + pass + + elif la_ == 26: + self.enterOuterAlt(localctx, 26) + self.state = 1710 + self.match(PLpgSQLParser.REPLICA) + self.state = 1711 + self.match(PLpgSQLParser.IDENTITY) + self.state = 1718 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DEFAULT]: + self.state = 1712 + self.match(PLpgSQLParser.DEFAULT) + pass + elif token in [PLpgSQLParser.FULL]: + self.state = 1713 + self.match(PLpgSQLParser.FULL) + pass + elif token in [PLpgSQLParser.NOTHING]: + self.state = 1714 + self.match(PLpgSQLParser.NOTHING) + pass + elif token in [PLpgSQLParser.USING]: + self.state = 1715 + self.match(PLpgSQLParser.USING) + self.state = 1716 + self.match(PLpgSQLParser.INDEX) + self.state = 1717 + self.identifier() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 27: + self.enterOuterAlt(localctx, 27) + self.state = 1720 + self.match(PLpgSQLParser.ALTER) + self.state = 1721 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 1722 + self.identifier() + self.state = 1724 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFERRABLE or _la==PLpgSQLParser.NOT: + self.state = 1723 + self.table_deferrable() + + + self.state = 1727 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INITIALLY: + self.state = 1726 + self.table_initialy_immed() + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Column_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.set = None # Token + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def collate_identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Collate_identifierContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def identity_body(self): + return self.getTypedRuleContext(PLpgSQLParser.Identity_bodyContext,0) + + + def set_def_column(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_def_columnContext,0) + + + def drop_def(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_defContext,0) + + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def IDENTITY(self): + return self.getToken(PLpgSQLParser.IDENTITY, 0) + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def signed_number_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Signed_number_literalContext,0) + + + def STORAGE(self): + return self.getToken(PLpgSQLParser.STORAGE, 0) + + def storage_option(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_optionContext,0) + + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def names_in_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,0) + + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def alter_identity(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Alter_identityContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Alter_identityContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_column_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterColumn_action" ): + listener.enterColumn_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitColumn_action" ): + listener.exitColumn_action(self) + + + + + def column_action(self): + + localctx = PLpgSQLParser.Column_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_column_action) + self._la = 0 # Token type + try: + self.state = 1775 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,144,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1733 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.SET: + self.state = 1731 + self.match(PLpgSQLParser.SET) + self.state = 1732 + self.match(PLpgSQLParser.DATA) + + + self.state = 1735 + self.match(PLpgSQLParser.TYPE) + self.state = 1736 + self.data_type() + self.state = 1738 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLLATE: + self.state = 1737 + self.collate_identifier() + + + self.state = 1742 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 1740 + self.match(PLpgSQLParser.USING) + self.state = 1741 + self.vex(0) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1744 + self.match(PLpgSQLParser.ADD) + self.state = 1745 + self.identity_body() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1746 + self.set_def_column() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1747 + self.drop_def() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1750 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SET]: + self.state = 1748 + localctx.set = self.match(PLpgSQLParser.SET) + pass + elif token in [PLpgSQLParser.DROP]: + self.state = 1749 + self.match(PLpgSQLParser.DROP) + pass + else: + raise NoViableAltException(self) + + self.state = 1752 + self.match(PLpgSQLParser.NOT) + self.state = 1753 + self.match(PLpgSQLParser.NULL) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1754 + self.match(PLpgSQLParser.DROP) + self.state = 1755 + self.match(PLpgSQLParser.IDENTITY) + self.state = 1757 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IF: + self.state = 1756 + self.if_exists() + + + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1759 + self.match(PLpgSQLParser.SET) + self.state = 1760 + self.storage_parameter() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 1761 + self.match(PLpgSQLParser.SET) + self.state = 1762 + self.match(PLpgSQLParser.STATISTICS) + self.state = 1763 + self.signed_number_literal() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 1764 + self.match(PLpgSQLParser.SET) + self.state = 1765 + self.match(PLpgSQLParser.STORAGE) + self.state = 1766 + self.storage_option() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 1767 + self.match(PLpgSQLParser.RESET) + self.state = 1768 + self.names_in_parens() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 1769 + self.define_foreign_options() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 1771 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1770 + self.alter_identity() + self.state = 1773 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.RESTART or _la==PLpgSQLParser.SET): + break + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Identity_bodyContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GENERATED(self): + return self.getToken(PLpgSQLParser.GENERATED, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def IDENTITY(self): + return self.getToken(PLpgSQLParser.IDENTITY, 0) + + def ALWAYS(self): + return self.getToken(PLpgSQLParser.ALWAYS, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def sequence_body(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Sequence_bodyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Sequence_bodyContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_identity_body + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentity_body" ): + listener.enterIdentity_body(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentity_body" ): + listener.exitIdentity_body(self) + + + + + def identity_body(self): + + localctx = PLpgSQLParser.Identity_bodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_identity_body) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1777 + self.match(PLpgSQLParser.GENERATED) + self.state = 1781 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALWAYS]: + self.state = 1778 + self.match(PLpgSQLParser.ALWAYS) + pass + elif token in [PLpgSQLParser.BY]: + self.state = 1779 + self.match(PLpgSQLParser.BY) + self.state = 1780 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + self.state = 1783 + self.match(PLpgSQLParser.AS) + self.state = 1784 + self.match(PLpgSQLParser.IDENTITY) + self.state = 1793 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 1785 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1787 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1786 + self.sequence_body() + self.state = 1789 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.CACHE or _la==PLpgSQLParser.CYCLE or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (PLpgSQLParser.INCREMENT - 110)) | (1 << (PLpgSQLParser.MAXVALUE - 110)) | (1 << (PLpgSQLParser.MINVALUE - 110)) | (1 << (PLpgSQLParser.NO - 110)) | (1 << (PLpgSQLParser.OWNED - 110)))) != 0) or _la==PLpgSQLParser.SEQUENCE or _la==PLpgSQLParser.START or _la==PLpgSQLParser.AS): + break + + self.state = 1791 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_identityContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def GENERATED(self): + return self.getToken(PLpgSQLParser.GENERATED, 0) + + def ALWAYS(self): + return self.getToken(PLpgSQLParser.ALWAYS, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def sequence_body(self): + return self.getTypedRuleContext(PLpgSQLParser.Sequence_bodyContext,0) + + + def RESTART(self): + return self.getToken(PLpgSQLParser.RESTART, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_identity + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_identity" ): + listener.enterAlter_identity(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_identity" ): + listener.exitAlter_identity(self) + + + + + def alter_identity(self): + + localctx = PLpgSQLParser.Alter_identityContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_alter_identity) + self._la = 0 # Token type + try: + self.state = 1811 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,151,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1795 + self.match(PLpgSQLParser.SET) + self.state = 1796 + self.match(PLpgSQLParser.GENERATED) + self.state = 1800 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALWAYS]: + self.state = 1797 + self.match(PLpgSQLParser.ALWAYS) + pass + elif token in [PLpgSQLParser.BY]: + self.state = 1798 + self.match(PLpgSQLParser.BY) + self.state = 1799 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1802 + self.match(PLpgSQLParser.SET) + self.state = 1803 + self.sequence_body() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1804 + self.match(PLpgSQLParser.RESTART) + self.state = 1809 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH or _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 1806 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 1805 + self.match(PLpgSQLParser.WITH) + + + self.state = 1808 + self.match(PLpgSQLParser.NUMBER_LITERAL) + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Storage_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PLAIN(self): + return self.getToken(PLpgSQLParser.PLAIN, 0) + + def EXTERNAL(self): + return self.getToken(PLpgSQLParser.EXTERNAL, 0) + + def EXTENDED(self): + return self.getToken(PLpgSQLParser.EXTENDED, 0) + + def MAIN(self): + return self.getToken(PLpgSQLParser.MAIN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_storage_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStorage_option" ): + listener.enterStorage_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStorage_option" ): + listener.exitStorage_option(self) + + + + + def storage_option(self): + + localctx = PLpgSQLParser.Storage_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 92, self.RULE_storage_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1813 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.EXTERNAL or ((((_la - 460)) & ~0x3f) == 0 and ((1 << (_la - 460)) & ((1 << (PLpgSQLParser.EXTENDED - 460)) | (1 << (PLpgSQLParser.MAIN - 460)) | (1 << (PLpgSQLParser.PLAIN - 460)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Validate_constraintContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.constraint_name = None # Schema_qualified_nameContext + + def VALIDATE(self): + return self.getToken(PLpgSQLParser.VALIDATE, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_validate_constraint + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValidate_constraint" ): + listener.enterValidate_constraint(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValidate_constraint" ): + listener.exitValidate_constraint(self) + + + + + def validate_constraint(self): + + localctx = PLpgSQLParser.Validate_constraintContext(self, self._ctx, self.state) + self.enterRule(localctx, 94, self.RULE_validate_constraint) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1815 + self.match(PLpgSQLParser.VALIDATE) + self.state = 1816 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 1817 + localctx.constraint_name = self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_constraintContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.constraint_name = None # IdentifierContext + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_constraint + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_constraint" ): + listener.enterDrop_constraint(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_constraint" ): + listener.exitDrop_constraint(self) + + + + + def drop_constraint(self): + + localctx = PLpgSQLParser.Drop_constraintContext(self, self._ctx, self.state) + self.enterRule(localctx, 96, self.RULE_drop_constraint) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1819 + self.match(PLpgSQLParser.DROP) + self.state = 1820 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 1822 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,152,self._ctx) + if la_ == 1: + self.state = 1821 + self.if_exists() + + + self.state = 1824 + localctx.constraint_name = self.identifier() + self.state = 1826 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 1825 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_deferrableContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DEFERRABLE(self): + return self.getToken(PLpgSQLParser.DEFERRABLE, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_deferrable + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_deferrable" ): + listener.enterTable_deferrable(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_deferrable" ): + listener.exitTable_deferrable(self) + + + + + def table_deferrable(self): + + localctx = PLpgSQLParser.Table_deferrableContext(self, self._ctx, self.state) + self.enterRule(localctx, 98, self.RULE_table_deferrable) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1829 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 1828 + self.match(PLpgSQLParser.NOT) + + + self.state = 1831 + self.match(PLpgSQLParser.DEFERRABLE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_initialy_immedContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INITIALLY(self): + return self.getToken(PLpgSQLParser.INITIALLY, 0) + + def DEFERRED(self): + return self.getToken(PLpgSQLParser.DEFERRED, 0) + + def IMMEDIATE(self): + return self.getToken(PLpgSQLParser.IMMEDIATE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_initialy_immed + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_initialy_immed" ): + listener.enterTable_initialy_immed(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_initialy_immed" ): + listener.exitTable_initialy_immed(self) + + + + + def table_initialy_immed(self): + + localctx = PLpgSQLParser.Table_initialy_immedContext(self, self._ctx, self.state) + self.enterRule(localctx, 100, self.RULE_table_initialy_immed) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1833 + self.match(PLpgSQLParser.INITIALLY) + self.state = 1834 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DEFERRED or _la==PLpgSQLParser.IMMEDIATE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_actions_commonContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.execution_cost = None # Unsigned_numeric_literalContext + self.result_rows = None # Unsigned_numeric_literalContext + self.config_scope = None # IdentifierContext + self.config_param = None # IdentifierContext + self.lang_name = None # IdentifierContext + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def NULL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NULL) + else: + return self.getToken(PLpgSQLParser.NULL, i) + + def INPUT(self): + return self.getToken(PLpgSQLParser.INPUT, 0) + + def CALLED(self): + return self.getToken(PLpgSQLParser.CALLED, 0) + + def RETURNS(self): + return self.getToken(PLpgSQLParser.RETURNS, 0) + + def TRANSFORM(self): + return self.getToken(PLpgSQLParser.TRANSFORM, 0) + + def transform_for_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Transform_for_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Transform_for_typeContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def STRICT(self): + return self.getToken(PLpgSQLParser.STRICT, 0) + + def IMMUTABLE(self): + return self.getToken(PLpgSQLParser.IMMUTABLE, 0) + + def VOLATILE(self): + return self.getToken(PLpgSQLParser.VOLATILE, 0) + + def STABLE(self): + return self.getToken(PLpgSQLParser.STABLE, 0) + + def LEAKPROOF(self): + return self.getToken(PLpgSQLParser.LEAKPROOF, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def SECURITY(self): + return self.getToken(PLpgSQLParser.SECURITY, 0) + + def INVOKER(self): + return self.getToken(PLpgSQLParser.INVOKER, 0) + + def DEFINER(self): + return self.getToken(PLpgSQLParser.DEFINER, 0) + + def EXTERNAL(self): + return self.getToken(PLpgSQLParser.EXTERNAL, 0) + + def PARALLEL(self): + return self.getToken(PLpgSQLParser.PARALLEL, 0) + + def SAFE(self): + return self.getToken(PLpgSQLParser.SAFE, 0) + + def UNSAFE(self): + return self.getToken(PLpgSQLParser.UNSAFE, 0) + + def RESTRICTED(self): + return self.getToken(PLpgSQLParser.RESTRICTED, 0) + + def COST(self): + return self.getToken(PLpgSQLParser.COST, 0) + + def unsigned_numeric_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_numeric_literalContext,0) + + + def ROWS(self): + return self.getToken(PLpgSQLParser.ROWS, 0) + + def SUPPORT(self): + return self.getToken(PLpgSQLParser.SUPPORT, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def set_statement_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_statement_valueContext,0) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def WINDOW(self): + return self.getToken(PLpgSQLParser.WINDOW, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def function_def(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_defContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_actions_common + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_actions_common" ): + listener.enterFunction_actions_common(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_actions_common" ): + listener.exitFunction_actions_common(self) + + + + + def function_actions_common(self): + + localctx = PLpgSQLParser.Function_actions_commonContext(self, self._ctx, self.state) + self.enterRule(localctx, 102, self.RULE_function_actions_common) + self._la = 0 # Token type + try: + self.state = 1892 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CALLED, PLpgSQLParser.RETURNS]: + self.enterOuterAlt(localctx, 1) + self.state = 1839 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CALLED]: + self.state = 1836 + self.match(PLpgSQLParser.CALLED) + pass + elif token in [PLpgSQLParser.RETURNS]: + self.state = 1837 + self.match(PLpgSQLParser.RETURNS) + self.state = 1838 + self.match(PLpgSQLParser.NULL) + pass + else: + raise NoViableAltException(self) + + self.state = 1841 + self.match(PLpgSQLParser.ON) + self.state = 1842 + self.match(PLpgSQLParser.NULL) + self.state = 1843 + self.match(PLpgSQLParser.INPUT) + pass + elif token in [PLpgSQLParser.TRANSFORM]: + self.enterOuterAlt(localctx, 2) + self.state = 1844 + self.match(PLpgSQLParser.TRANSFORM) + self.state = 1845 + self.transform_for_type() + self.state = 1850 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1846 + self.match(PLpgSQLParser.COMMA) + self.state = 1847 + self.transform_for_type() + self.state = 1852 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + elif token in [PLpgSQLParser.STRICT]: + self.enterOuterAlt(localctx, 3) + self.state = 1853 + self.match(PLpgSQLParser.STRICT) + pass + elif token in [PLpgSQLParser.IMMUTABLE]: + self.enterOuterAlt(localctx, 4) + self.state = 1854 + self.match(PLpgSQLParser.IMMUTABLE) + pass + elif token in [PLpgSQLParser.VOLATILE]: + self.enterOuterAlt(localctx, 5) + self.state = 1855 + self.match(PLpgSQLParser.VOLATILE) + pass + elif token in [PLpgSQLParser.STABLE]: + self.enterOuterAlt(localctx, 6) + self.state = 1856 + self.match(PLpgSQLParser.STABLE) + pass + elif token in [PLpgSQLParser.LEAKPROOF, PLpgSQLParser.NOT]: + self.enterOuterAlt(localctx, 7) + self.state = 1858 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 1857 + self.match(PLpgSQLParser.NOT) + + + self.state = 1860 + self.match(PLpgSQLParser.LEAKPROOF) + pass + elif token in [PLpgSQLParser.EXTERNAL, PLpgSQLParser.SECURITY]: + self.enterOuterAlt(localctx, 8) + self.state = 1862 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.EXTERNAL: + self.state = 1861 + self.match(PLpgSQLParser.EXTERNAL) + + + self.state = 1864 + self.match(PLpgSQLParser.SECURITY) + self.state = 1865 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DEFINER or _la==PLpgSQLParser.INVOKER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.PARALLEL]: + self.enterOuterAlt(localctx, 9) + self.state = 1866 + self.match(PLpgSQLParser.PARALLEL) + self.state = 1867 + _la = self._input.LA(1) + if not(((((_la - 517)) & ~0x3f) == 0 and ((1 << (_la - 517)) & ((1 << (PLpgSQLParser.RESTRICTED - 517)) | (1 << (PLpgSQLParser.SAFE - 517)) | (1 << (PLpgSQLParser.UNSAFE - 517)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.COST]: + self.enterOuterAlt(localctx, 10) + self.state = 1868 + self.match(PLpgSQLParser.COST) + self.state = 1869 + localctx.execution_cost = self.unsigned_numeric_literal() + pass + elif token in [PLpgSQLParser.ROWS]: + self.enterOuterAlt(localctx, 11) + self.state = 1870 + self.match(PLpgSQLParser.ROWS) + self.state = 1871 + localctx.result_rows = self.unsigned_numeric_literal() + pass + elif token in [PLpgSQLParser.SUPPORT]: + self.enterOuterAlt(localctx, 12) + self.state = 1872 + self.match(PLpgSQLParser.SUPPORT) + self.state = 1873 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.SET]: + self.enterOuterAlt(localctx, 13) + self.state = 1874 + self.match(PLpgSQLParser.SET) + self.state = 1878 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,159,self._ctx) + if la_ == 1: + self.state = 1875 + localctx.config_scope = self.identifier() + self.state = 1876 + self.match(PLpgSQLParser.DOT) + + + self.state = 1880 + localctx.config_param = self.identifier() + self.state = 1885 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.TO, PLpgSQLParser.EQUAL]: + self.state = 1881 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TO or _la==PLpgSQLParser.EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1882 + self.set_statement_value() + pass + elif token in [PLpgSQLParser.FROM]: + self.state = 1883 + self.match(PLpgSQLParser.FROM) + self.state = 1884 + self.match(PLpgSQLParser.CURRENT) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.LANGUAGE]: + self.enterOuterAlt(localctx, 14) + self.state = 1887 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 1888 + localctx.lang_name = self.identifier() + pass + elif token in [PLpgSQLParser.WINDOW]: + self.enterOuterAlt(localctx, 15) + self.state = 1889 + self.match(PLpgSQLParser.WINDOW) + pass + elif token in [PLpgSQLParser.AS]: + self.enterOuterAlt(localctx, 16) + self.state = 1890 + self.match(PLpgSQLParser.AS) + self.state = 1891 + self.function_def() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_defContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.definition = None # Character_stringContext + self.symbol = None # Character_stringContext + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_def + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_def" ): + listener.enterFunction_def(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_def" ): + listener.exitFunction_def(self) + + + + + def function_def(self): + + localctx = PLpgSQLParser.Function_defContext(self, self._ctx, self.state) + self.enterRule(localctx, 104, self.RULE_function_def) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1894 + localctx.definition = self.character_string() + self.state = 1897 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 1895 + self.match(PLpgSQLParser.COMMA) + self.state = 1896 + localctx.symbol = self.character_string() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_index_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def index_def_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_def_actionContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def TABLESPACE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.TABLESPACE) + else: + return self.getToken(PLpgSQLParser.TABLESPACE, i) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def OWNED(self): + return self.getToken(PLpgSQLParser.OWNED, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def NOWAIT(self): + return self.getToken(PLpgSQLParser.NOWAIT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_index_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_index_statement" ): + listener.enterAlter_index_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_index_statement" ): + listener.exitAlter_index_statement(self) + + + + + def alter_index_statement(self): + + localctx = PLpgSQLParser.Alter_index_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 106, self.RULE_alter_index_statement) + self._la = 0 # Token type + try: + self.state = 1922 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,166,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1899 + self.match(PLpgSQLParser.INDEX) + self.state = 1901 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,163,self._ctx) + if la_ == 1: + self.state = 1900 + self.if_exists() + + + self.state = 1903 + self.schema_qualified_name() + self.state = 1904 + self.index_def_action() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1906 + self.match(PLpgSQLParser.INDEX) + self.state = 1907 + self.match(PLpgSQLParser.ALL) + self.state = 1908 + self.match(PLpgSQLParser.IN) + self.state = 1909 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 1910 + self.identifier() + self.state = 1914 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OWNED: + self.state = 1911 + self.match(PLpgSQLParser.OWNED) + self.state = 1912 + self.match(PLpgSQLParser.BY) + self.state = 1913 + self.identifier_list() + + + self.state = 1916 + self.match(PLpgSQLParser.SET) + self.state = 1917 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 1918 + self.identifier() + self.state = 1920 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOWAIT: + self.state = 1919 + self.match(PLpgSQLParser.NOWAIT) + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Index_def_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.index = None # Schema_qualified_nameContext + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def ATTACH(self): + return self.getToken(PLpgSQLParser.ATTACH, 0) + + def PARTITION(self): + return self.getToken(PLpgSQLParser.PARTITION, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def DEPENDS(self): + return self.getToken(PLpgSQLParser.DEPENDS, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def signed_number_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Signed_number_literalContext,0) + + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def sign(self): + return self.getTypedRuleContext(PLpgSQLParser.SignContext,0) + + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def option_with_value(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Option_with_valueContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Option_with_valueContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_index_def_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndex_def_action" ): + listener.enterIndex_def_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndex_def_action" ): + listener.exitIndex_def_action(self) + + + + + def index_def_action(self): + + localctx = PLpgSQLParser.Index_def_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 108, self.RULE_index_def_action) + self._la = 0 # Token type + try: + self.state = 1963 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,170,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1924 + self.rename_to() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1925 + self.match(PLpgSQLParser.ATTACH) + self.state = 1926 + self.match(PLpgSQLParser.PARTITION) + self.state = 1927 + localctx.index = self.schema_qualified_name() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1928 + self.match(PLpgSQLParser.DEPENDS) + self.state = 1929 + self.match(PLpgSQLParser.ON) + self.state = 1930 + self.match(PLpgSQLParser.EXTENSION) + self.state = 1931 + self.schema_qualified_name() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1932 + self.match(PLpgSQLParser.ALTER) + self.state = 1934 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLUMN: + self.state = 1933 + self.match(PLpgSQLParser.COLUMN) + + + self.state = 1937 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS: + self.state = 1936 + self.sign() + + + self.state = 1939 + self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 1940 + self.match(PLpgSQLParser.SET) + self.state = 1941 + self.match(PLpgSQLParser.STATISTICS) + self.state = 1942 + self.signed_number_literal() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1943 + self.match(PLpgSQLParser.RESET) + self.state = 1944 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1945 + self.identifier_list() + self.state = 1946 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1948 + self.match(PLpgSQLParser.SET) + self.state = 1949 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 1950 + self.identifier() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1951 + self.match(PLpgSQLParser.SET) + self.state = 1952 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 1953 + self.option_with_value() + self.state = 1958 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1954 + self.match(PLpgSQLParser.COMMA) + self.state = 1955 + self.option_with_value() + self.state = 1960 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1961 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_default_privilegesContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def PRIVILEGES(self): + return self.getToken(PLpgSQLParser.PRIVILEGES, 0) + + def abbreviated_grant_or_revoke(self): + return self.getTypedRuleContext(PLpgSQLParser.Abbreviated_grant_or_revokeContext,0) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def identifier_list(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Identifier_listContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,i) + + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_default_privileges + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_default_privileges" ): + listener.enterAlter_default_privileges(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_default_privileges" ): + listener.exitAlter_default_privileges(self) + + + + + def alter_default_privileges(self): + + localctx = PLpgSQLParser.Alter_default_privilegesContext(self, self._ctx, self.state) + self.enterRule(localctx, 110, self.RULE_alter_default_privileges) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1965 + self.match(PLpgSQLParser.DEFAULT) + self.state = 1966 + self.match(PLpgSQLParser.PRIVILEGES) + self.state = 1970 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 1967 + self.match(PLpgSQLParser.FOR) + self.state = 1968 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.USER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1969 + self.identifier_list() + + + self.state = 1975 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IN: + self.state = 1972 + self.match(PLpgSQLParser.IN) + self.state = 1973 + self.match(PLpgSQLParser.SCHEMA) + self.state = 1974 + self.identifier_list() + + + self.state = 1977 + self.abbreviated_grant_or_revoke() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Abbreviated_grant_or_revokeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GRANT(self): + return self.getToken(PLpgSQLParser.GRANT, 0) + + def REVOKE(self): + return self.getToken(PLpgSQLParser.REVOKE, 0) + + def table_column_privilege(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_column_privilegeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_column_privilegeContext,i) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def TABLES(self): + return self.getToken(PLpgSQLParser.TABLES, 0) + + def SEQUENCES(self): + return self.getToken(PLpgSQLParser.SEQUENCES, 0) + + def FUNCTIONS(self): + return self.getToken(PLpgSQLParser.FUNCTIONS, 0) + + def SCHEMAS(self): + return self.getToken(PLpgSQLParser.SCHEMAS, 0) + + def TYPES(self): + return self.getToken(PLpgSQLParser.TYPES, 0) + + def grant_to_rule(self): + return self.getTypedRuleContext(PLpgSQLParser.Grant_to_ruleContext,0) + + + def revoke_from_cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Revoke_from_cascade_restrictContext,0) + + + def usage_select_update(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Usage_select_updateContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Usage_select_updateContext,i) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def USAGE(self): + return self.getToken(PLpgSQLParser.USAGE, 0) + + def CREATE(self): + return self.getToken(PLpgSQLParser.CREATE, 0) + + def grant_option_for(self): + return self.getTypedRuleContext(PLpgSQLParser.Grant_option_forContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def PRIVILEGES(self): + return self.getToken(PLpgSQLParser.PRIVILEGES, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_abbreviated_grant_or_revoke + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAbbreviated_grant_or_revoke" ): + listener.enterAbbreviated_grant_or_revoke(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAbbreviated_grant_or_revoke" ): + listener.exitAbbreviated_grant_or_revoke(self) + + + + + def abbreviated_grant_or_revoke(self): + + localctx = PLpgSQLParser.Abbreviated_grant_or_revokeContext(self, self._ctx, self.state) + self.enterRule(localctx, 112, self.RULE_abbreviated_grant_or_revoke) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1984 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.GRANT]: + self.state = 1979 + self.match(PLpgSQLParser.GRANT) + pass + elif token in [PLpgSQLParser.REVOKE]: + self.state = 1980 + self.match(PLpgSQLParser.REVOKE) + self.state = 1982 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GRANT: + self.state = 1981 + self.grant_option_for() + + + pass + else: + raise NoViableAltException(self) + + self.state = 2041 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,185,self._ctx) + if la_ == 1: + self.state = 1986 + self.table_column_privilege() + self.state = 1991 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1987 + self.match(PLpgSQLParser.COMMA) + self.state = 1988 + self.table_column_privilege() + self.state = 1993 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1994 + self.match(PLpgSQLParser.ON) + self.state = 1995 + self.match(PLpgSQLParser.TABLES) + pass + + elif la_ == 2: + self.state = 2009 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.UPDATE, PLpgSQLParser.SELECT, PLpgSQLParser.USAGE]: + self.state = 1997 + self.usage_select_update() + self.state = 2002 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 1998 + self.match(PLpgSQLParser.COMMA) + self.state = 1999 + self.usage_select_update() + self.state = 2004 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 2005 + self.match(PLpgSQLParser.ALL) + self.state = 2007 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PRIVILEGES: + self.state = 2006 + self.match(PLpgSQLParser.PRIVILEGES) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2011 + self.match(PLpgSQLParser.ON) + self.state = 2012 + self.match(PLpgSQLParser.SEQUENCES) + pass + + elif la_ == 3: + self.state = 2018 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.EXECUTE]: + self.state = 2013 + self.match(PLpgSQLParser.EXECUTE) + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 2014 + self.match(PLpgSQLParser.ALL) + self.state = 2016 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PRIVILEGES: + self.state = 2015 + self.match(PLpgSQLParser.PRIVILEGES) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2020 + self.match(PLpgSQLParser.ON) + self.state = 2021 + self.match(PLpgSQLParser.FUNCTIONS) + pass + + elif la_ == 4: + self.state = 2028 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.USAGE]: + self.state = 2022 + self.match(PLpgSQLParser.USAGE) + pass + elif token in [PLpgSQLParser.CREATE]: + self.state = 2023 + self.match(PLpgSQLParser.CREATE) + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 2024 + self.match(PLpgSQLParser.ALL) + self.state = 2026 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PRIVILEGES: + self.state = 2025 + self.match(PLpgSQLParser.PRIVILEGES) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2030 + self.match(PLpgSQLParser.ON) + self.state = 2031 + self.match(PLpgSQLParser.SCHEMAS) + pass + + elif la_ == 5: + self.state = 2037 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.USAGE]: + self.state = 2032 + self.match(PLpgSQLParser.USAGE) + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 2033 + self.match(PLpgSQLParser.ALL) + self.state = 2035 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PRIVILEGES: + self.state = 2034 + self.match(PLpgSQLParser.PRIVILEGES) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2039 + self.match(PLpgSQLParser.ON) + self.state = 2040 + self.match(PLpgSQLParser.TYPES) + pass + + + self.state = 2045 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.TO]: + self.state = 2043 + self.grant_to_rule() + pass + elif token in [PLpgSQLParser.FROM]: + self.state = 2044 + self.revoke_from_cascade_restrict() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Grant_option_forContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GRANT(self): + return self.getToken(PLpgSQLParser.GRANT, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_grant_option_for + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGrant_option_for" ): + listener.enterGrant_option_for(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGrant_option_for" ): + listener.exitGrant_option_for(self) + + + + + def grant_option_for(self): + + localctx = PLpgSQLParser.Grant_option_forContext(self, self._ctx, self.state) + self.enterRule(localctx, 114, self.RULE_grant_option_for) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2047 + self.match(PLpgSQLParser.GRANT) + self.state = 2048 + self.match(PLpgSQLParser.OPTION) + self.state = 2049 + self.match(PLpgSQLParser.FOR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_sequence_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def sequence_body(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Sequence_bodyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Sequence_bodyContext,i) + + + def RESTART(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RESTART) + else: + return self.getToken(PLpgSQLParser.RESTART, i) + + def signed_number_literal(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Signed_number_literalContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Signed_number_literalContext,i) + + + def WITH(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WITH) + else: + return self.getToken(PLpgSQLParser.WITH, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_sequence_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_sequence_statement" ): + listener.enterAlter_sequence_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_sequence_statement" ): + listener.exitAlter_sequence_statement(self) + + + + + def alter_sequence_statement(self): + + localctx = PLpgSQLParser.Alter_sequence_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 116, self.RULE_alter_sequence_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2051 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 2053 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,187,self._ctx) + if la_ == 1: + self.state = 2052 + self.if_exists() + + + self.state = 2055 + localctx.name = self.schema_qualified_name() + self.state = 2071 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.EOF, PLpgSQLParser.CACHE, PLpgSQLParser.CYCLE, PLpgSQLParser.INCREMENT, PLpgSQLParser.MAXVALUE, PLpgSQLParser.MINVALUE, PLpgSQLParser.NO, PLpgSQLParser.OWNED, PLpgSQLParser.RESTART, PLpgSQLParser.SEQUENCE, PLpgSQLParser.START, PLpgSQLParser.AS, PLpgSQLParser.SEMI_COLON]: + self.state = 2066 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.CACHE or _la==PLpgSQLParser.CYCLE or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (PLpgSQLParser.INCREMENT - 110)) | (1 << (PLpgSQLParser.MAXVALUE - 110)) | (1 << (PLpgSQLParser.MINVALUE - 110)) | (1 << (PLpgSQLParser.NO - 110)) | (1 << (PLpgSQLParser.OWNED - 110)))) != 0) or ((((_la - 205)) & ~0x3f) == 0 and ((1 << (_la - 205)) & ((1 << (PLpgSQLParser.RESTART - 205)) | (1 << (PLpgSQLParser.SEQUENCE - 205)) | (1 << (PLpgSQLParser.START - 205)))) != 0) or _la==PLpgSQLParser.AS: + self.state = 2064 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CACHE, PLpgSQLParser.CYCLE, PLpgSQLParser.INCREMENT, PLpgSQLParser.MAXVALUE, PLpgSQLParser.MINVALUE, PLpgSQLParser.NO, PLpgSQLParser.OWNED, PLpgSQLParser.SEQUENCE, PLpgSQLParser.START, PLpgSQLParser.AS]: + self.state = 2056 + self.sequence_body() + pass + elif token in [PLpgSQLParser.RESTART]: + self.state = 2057 + self.match(PLpgSQLParser.RESTART) + self.state = 2062 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH or ((((_la - 587)) & ~0x3f) == 0 and ((1 << (_la - 587)) & ((1 << (PLpgSQLParser.PLUS - 587)) | (1 << (PLpgSQLParser.MINUS - 587)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 587)))) != 0): + self.state = 2059 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 2058 + self.match(PLpgSQLParser.WITH) + + + self.state = 2061 + self.signed_number_literal() + + + pass + else: + raise NoViableAltException(self) + + self.state = 2068 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + elif token in [PLpgSQLParser.SET]: + self.state = 2069 + self.set_schema() + pass + elif token in [PLpgSQLParser.RENAME]: + self.state = 2070 + self.rename_to() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_view_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.column_name = None # Schema_qualified_nameContext + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def names_in_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,0) + + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def set_def_column(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_def_columnContext,0) + + + def drop_def(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_defContext,0) + + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_view_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_view_statement" ): + listener.enterAlter_view_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_view_statement" ): + listener.exitAlter_view_statement(self) + + + + + def alter_view_statement(self): + + localctx = PLpgSQLParser.Alter_view_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 118, self.RULE_alter_view_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2074 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 2073 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 2076 + self.match(PLpgSQLParser.VIEW) + self.state = 2078 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,194,self._ctx) + if la_ == 1: + self.state = 2077 + self.if_exists() + + + self.state = 2080 + localctx.name = self.schema_qualified_name() + self.state = 2096 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,197,self._ctx) + if la_ == 1: + self.state = 2081 + self.match(PLpgSQLParser.ALTER) + self.state = 2083 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLUMN: + self.state = 2082 + self.match(PLpgSQLParser.COLUMN) + + + self.state = 2085 + localctx.column_name = self.schema_qualified_name() + self.state = 2088 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SET]: + self.state = 2086 + self.set_def_column() + pass + elif token in [PLpgSQLParser.DROP]: + self.state = 2087 + self.drop_def() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.state = 2090 + self.set_schema() + pass + + elif la_ == 3: + self.state = 2091 + self.rename_to() + pass + + elif la_ == 4: + self.state = 2092 + self.match(PLpgSQLParser.SET) + self.state = 2093 + self.storage_parameter() + pass + + elif la_ == 5: + self.state = 2094 + self.match(PLpgSQLParser.RESET) + self.state = 2095 + self.names_in_parens() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_event_triggerContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def alter_event_trigger_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_event_trigger_actionContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_event_trigger + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_event_trigger" ): + listener.enterAlter_event_trigger(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_event_trigger" ): + listener.exitAlter_event_trigger(self) + + + + + def alter_event_trigger(self): + + localctx = PLpgSQLParser.Alter_event_triggerContext(self, self._ctx, self.state) + self.enterRule(localctx, 120, self.RULE_alter_event_trigger) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2098 + self.match(PLpgSQLParser.EVENT) + self.state = 2099 + self.match(PLpgSQLParser.TRIGGER) + self.state = 2100 + localctx.name = self.identifier() + self.state = 2101 + self.alter_event_trigger_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_event_trigger_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISABLE(self): + return self.getToken(PLpgSQLParser.DISABLE, 0) + + def ENABLE(self): + return self.getToken(PLpgSQLParser.ENABLE, 0) + + def REPLICA(self): + return self.getToken(PLpgSQLParser.REPLICA, 0) + + def ALWAYS(self): + return self.getToken(PLpgSQLParser.ALWAYS, 0) + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_event_trigger_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_event_trigger_action" ): + listener.enterAlter_event_trigger_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_event_trigger_action" ): + listener.exitAlter_event_trigger_action(self) + + + + + def alter_event_trigger_action(self): + + localctx = PLpgSQLParser.Alter_event_trigger_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 122, self.RULE_alter_event_trigger_action) + self._la = 0 # Token type + try: + self.state = 2110 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DISABLE]: + self.enterOuterAlt(localctx, 1) + self.state = 2103 + self.match(PLpgSQLParser.DISABLE) + pass + elif token in [PLpgSQLParser.ENABLE]: + self.enterOuterAlt(localctx, 2) + self.state = 2104 + self.match(PLpgSQLParser.ENABLE) + self.state = 2106 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALWAYS or _la==PLpgSQLParser.REPLICA: + self.state = 2105 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALWAYS or _la==PLpgSQLParser.REPLICA): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + pass + elif token in [PLpgSQLParser.OWNER]: + self.enterOuterAlt(localctx, 3) + self.state = 2108 + self.owner_to() + pass + elif token in [PLpgSQLParser.RENAME]: + self.enterOuterAlt(localctx, 4) + self.state = 2109 + self.rename_to() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_type_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.new_enum_value = None # Character_stringContext + self.existing_enum_value = None # Character_stringContext + self.attribute_name = None # IdentifierContext + self.new_attribute_name = None # IdentifierContext + self.existing_enum_name = None # Character_stringContext + self.new_enum_name = None # Character_stringContext + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def VALUE(self): + return self.getToken(PLpgSQLParser.VALUE, 0) + + def RENAME(self): + return self.getToken(PLpgSQLParser.RENAME, 0) + + def ATTRIBUTE(self): + return self.getToken(PLpgSQLParser.ATTRIBUTE, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def type_action(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Type_actionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Type_actionContext,i) + + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def BEFORE(self): + return self.getToken(PLpgSQLParser.BEFORE, 0) + + def AFTER(self): + return self.getToken(PLpgSQLParser.AFTER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_type_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_type_statement" ): + listener.enterAlter_type_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_type_statement" ): + listener.exitAlter_type_statement(self) + + + + + def alter_type_statement(self): + + localctx = PLpgSQLParser.Alter_type_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 124, self.RULE_alter_type_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2112 + self.match(PLpgSQLParser.TYPE) + self.state = 2113 + localctx.name = self.schema_qualified_name() + self.state = 2148 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,204,self._ctx) + if la_ == 1: + self.state = 2114 + self.set_schema() + pass + + elif la_ == 2: + self.state = 2115 + self.rename_to() + pass + + elif la_ == 3: + self.state = 2116 + self.match(PLpgSQLParser.ADD) + self.state = 2117 + self.match(PLpgSQLParser.VALUE) + self.state = 2119 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IF: + self.state = 2118 + self.if_not_exists() + + + self.state = 2121 + localctx.new_enum_value = self.character_string() + self.state = 2124 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AFTER or _la==PLpgSQLParser.BEFORE: + self.state = 2122 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.AFTER or _la==PLpgSQLParser.BEFORE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2123 + localctx.existing_enum_value = self.character_string() + + + pass + + elif la_ == 4: + self.state = 2126 + self.match(PLpgSQLParser.RENAME) + self.state = 2127 + self.match(PLpgSQLParser.ATTRIBUTE) + self.state = 2128 + localctx.attribute_name = self.identifier() + self.state = 2129 + self.match(PLpgSQLParser.TO) + self.state = 2130 + localctx.new_attribute_name = self.identifier() + self.state = 2132 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 2131 + self.cascade_restrict() + + + pass + + elif la_ == 5: + self.state = 2134 + self.match(PLpgSQLParser.RENAME) + self.state = 2135 + self.match(PLpgSQLParser.VALUE) + self.state = 2136 + localctx.existing_enum_name = self.character_string() + self.state = 2137 + self.match(PLpgSQLParser.TO) + self.state = 2138 + localctx.new_enum_name = self.character_string() + pass + + elif la_ == 6: + self.state = 2140 + self.type_action() + self.state = 2145 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2141 + self.match(PLpgSQLParser.COMMA) + self.state = 2142 + self.type_action() + self.state = 2147 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_domain_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.dom_constraint = None # Domain_constraintContext + self.not_valid = None # Token + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def set_def_column(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_def_columnContext,0) + + + def drop_def(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_defContext,0) + + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def drop_constraint(self): + return self.getTypedRuleContext(PLpgSQLParser.Drop_constraintContext,0) + + + def RENAME(self): + return self.getToken(PLpgSQLParser.RENAME, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def validate_constraint(self): + return self.getTypedRuleContext(PLpgSQLParser.Validate_constraintContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def domain_constraint(self): + return self.getTypedRuleContext(PLpgSQLParser.Domain_constraintContext,0) + + + def VALID(self): + return self.getToken(PLpgSQLParser.VALID, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_domain_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_domain_statement" ): + listener.enterAlter_domain_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_domain_statement" ): + listener.exitAlter_domain_statement(self) + + + + + def alter_domain_statement(self): + + localctx = PLpgSQLParser.Alter_domain_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 126, self.RULE_alter_domain_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2150 + self.match(PLpgSQLParser.DOMAIN) + self.state = 2151 + localctx.name = self.schema_qualified_name() + self.state = 2173 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,206,self._ctx) + if la_ == 1: + self.state = 2152 + self.set_def_column() + pass + + elif la_ == 2: + self.state = 2153 + self.drop_def() + pass + + elif la_ == 3: + self.state = 2154 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DROP or _la==PLpgSQLParser.SET): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2155 + self.match(PLpgSQLParser.NOT) + self.state = 2156 + self.match(PLpgSQLParser.NULL) + pass + + elif la_ == 4: + self.state = 2157 + self.match(PLpgSQLParser.ADD) + self.state = 2158 + localctx.dom_constraint = self.domain_constraint() + self.state = 2161 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 2159 + self.match(PLpgSQLParser.NOT) + self.state = 2160 + localctx.not_valid = self.match(PLpgSQLParser.VALID) + + + pass + + elif la_ == 5: + self.state = 2163 + self.drop_constraint() + pass + + elif la_ == 6: + self.state = 2164 + self.match(PLpgSQLParser.RENAME) + self.state = 2165 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 2166 + self.schema_qualified_name() + self.state = 2167 + self.match(PLpgSQLParser.TO) + self.state = 2168 + self.schema_qualified_name() + pass + + elif la_ == 7: + self.state = 2170 + self.validate_constraint() + pass + + elif la_ == 8: + self.state = 2171 + self.rename_to() + pass + + elif la_ == 9: + self.state = 2172 + self.set_schema() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_server_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def alter_server_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_server_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_server_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_server_statement" ): + listener.enterAlter_server_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_server_statement" ): + listener.exitAlter_server_statement(self) + + + + + def alter_server_statement(self): + + localctx = PLpgSQLParser.Alter_server_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 128, self.RULE_alter_server_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2175 + self.match(PLpgSQLParser.SERVER) + self.state = 2176 + self.identifier() + self.state = 2177 + self.alter_server_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_server_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_server_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_server_action" ): + listener.enterAlter_server_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_server_action" ): + listener.exitAlter_server_action(self) + + + + + def alter_server_action(self): + + localctx = PLpgSQLParser.Alter_server_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 130, self.RULE_alter_server_action) + self._la = 0 # Token type + try: + self.state = 2188 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,208,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2181 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERSION: + self.state = 2179 + self.match(PLpgSQLParser.VERSION) + self.state = 2180 + self.character_string() + + + self.state = 2183 + self.define_foreign_options() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2184 + self.match(PLpgSQLParser.VERSION) + self.state = 2185 + self.character_string() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2186 + self.owner_to() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2187 + self.rename_to() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_fts_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def alter_fts_configuration(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_fts_configurationContext,0) + + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_fts_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_fts_statement" ): + listener.enterAlter_fts_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_fts_statement" ): + listener.exitAlter_fts_statement(self) + + + + + def alter_fts_statement(self): + + localctx = PLpgSQLParser.Alter_fts_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 132, self.RULE_alter_fts_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2190 + self.match(PLpgSQLParser.TEXT) + self.state = 2191 + self.match(PLpgSQLParser.SEARCH) + self.state = 2206 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,210,self._ctx) + if la_ == 1: + self.state = 2192 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONFIGURATION or _la==PLpgSQLParser.DICTIONARY or _la==PLpgSQLParser.PARSER or _la==PLpgSQLParser.TEMPLATE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2193 + localctx.name = self.schema_qualified_name() + self.state = 2196 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 2194 + self.rename_to() + pass + elif token in [PLpgSQLParser.SET]: + self.state = 2195 + self.set_schema() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.state = 2198 + self.match(PLpgSQLParser.DICTIONARY) + self.state = 2199 + localctx.name = self.schema_qualified_name() + self.state = 2200 + self.storage_parameter() + pass + + elif la_ == 3: + self.state = 2202 + self.match(PLpgSQLParser.CONFIGURATION) + self.state = 2203 + localctx.name = self.schema_qualified_name() + self.state = 2204 + self.alter_fts_configuration() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_fts_configurationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MAPPING(self): + return self.getToken(PLpgSQLParser.MAPPING, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def IF(self): + return self.getToken(PLpgSQLParser.IF, 0) + + def EXISTS(self): + return self.getToken(PLpgSQLParser.EXISTS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_fts_configuration + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_fts_configuration" ): + listener.enterAlter_fts_configuration(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_fts_configuration" ): + listener.exitAlter_fts_configuration(self) + + + + + def alter_fts_configuration(self): + + localctx = PLpgSQLParser.Alter_fts_configurationContext(self, self._ctx, self.state) + self.enterRule(localctx, 134, self.RULE_alter_fts_configuration) + self._la = 0 # Token type + try: + self.state = 2240 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,214,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2208 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ADD or _la==PLpgSQLParser.ALTER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2209 + self.match(PLpgSQLParser.MAPPING) + self.state = 2210 + self.match(PLpgSQLParser.FOR) + self.state = 2211 + self.identifier_list() + self.state = 2212 + self.match(PLpgSQLParser.WITH) + self.state = 2213 + self.schema_qualified_name() + self.state = 2218 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2214 + self.match(PLpgSQLParser.COMMA) + self.state = 2215 + self.schema_qualified_name() + self.state = 2220 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2221 + self.match(PLpgSQLParser.ALTER) + self.state = 2222 + self.match(PLpgSQLParser.MAPPING) + self.state = 2225 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 2223 + self.match(PLpgSQLParser.FOR) + self.state = 2224 + self.identifier_list() + + + self.state = 2227 + self.match(PLpgSQLParser.REPLACE) + self.state = 2228 + self.schema_qualified_name() + self.state = 2229 + self.match(PLpgSQLParser.WITH) + self.state = 2230 + self.schema_qualified_name() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2232 + self.match(PLpgSQLParser.DROP) + self.state = 2233 + self.match(PLpgSQLParser.MAPPING) + self.state = 2236 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IF: + self.state = 2234 + self.match(PLpgSQLParser.IF) + self.state = 2235 + self.match(PLpgSQLParser.EXISTS) + + + self.state = 2238 + self.match(PLpgSQLParser.FOR) + self.state = 2239 + self.identifier_list() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Type_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def ATTRIBUTE(self): + return self.getToken(PLpgSQLParser.ATTRIBUTE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def collate_identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Collate_identifierContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_type_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterType_action" ): + listener.enterType_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitType_action" ): + listener.exitType_action(self) + + + + + def type_action(self): + + localctx = PLpgSQLParser.Type_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 136, self.RULE_type_action) + self._la = 0 # Token type + try: + self.state = 2276 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ADD]: + self.enterOuterAlt(localctx, 1) + self.state = 2242 + self.match(PLpgSQLParser.ADD) + self.state = 2243 + self.match(PLpgSQLParser.ATTRIBUTE) + self.state = 2244 + self.identifier() + self.state = 2245 + self.data_type() + self.state = 2247 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLLATE: + self.state = 2246 + self.collate_identifier() + + + self.state = 2250 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 2249 + self.cascade_restrict() + + + pass + elif token in [PLpgSQLParser.DROP]: + self.enterOuterAlt(localctx, 2) + self.state = 2252 + self.match(PLpgSQLParser.DROP) + self.state = 2253 + self.match(PLpgSQLParser.ATTRIBUTE) + self.state = 2255 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,217,self._ctx) + if la_ == 1: + self.state = 2254 + self.if_exists() + + + self.state = 2257 + self.identifier() + self.state = 2259 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 2258 + self.cascade_restrict() + + + pass + elif token in [PLpgSQLParser.ALTER]: + self.enterOuterAlt(localctx, 3) + self.state = 2261 + self.match(PLpgSQLParser.ALTER) + self.state = 2262 + self.match(PLpgSQLParser.ATTRIBUTE) + self.state = 2263 + self.identifier() + self.state = 2266 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.SET: + self.state = 2264 + self.match(PLpgSQLParser.SET) + self.state = 2265 + self.match(PLpgSQLParser.DATA) + + + self.state = 2268 + self.match(PLpgSQLParser.TYPE) + self.state = 2269 + self.data_type() + self.state = 2271 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLLATE: + self.state = 2270 + self.collate_identifier() + + + self.state = 2274 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 2273 + self.cascade_restrict() + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Set_def_columnContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_set_def_column + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet_def_column" ): + listener.enterSet_def_column(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet_def_column" ): + listener.exitSet_def_column(self) + + + + + def set_def_column(self): + + localctx = PLpgSQLParser.Set_def_columnContext(self, self._ctx, self.state) + self.enterRule(localctx, 138, self.RULE_set_def_column) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2278 + self.match(PLpgSQLParser.SET) + self.state = 2279 + self.match(PLpgSQLParser.DEFAULT) + self.state = 2280 + self.vex(0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_defContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_def + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_def" ): + listener.enterDrop_def(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_def" ): + listener.exitDrop_def(self) + + + + + def drop_def(self): + + localctx = PLpgSQLParser.Drop_defContext(self, self._ctx, self.state) + self.enterRule(localctx, 140, self.RULE_drop_def) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2282 + self.match(PLpgSQLParser.DROP) + self.state = 2283 + self.match(PLpgSQLParser.DEFAULT) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_index_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.table_name = None # Schema_qualified_nameContext + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def index_rest(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_restContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def UNIQUE(self): + return self.getToken(PLpgSQLParser.UNIQUE, 0) + + def CONCURRENTLY(self): + return self.getToken(PLpgSQLParser.CONCURRENTLY, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_index_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_index_statement" ): + listener.enterCreate_index_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_index_statement" ): + listener.exitCreate_index_statement(self) + + + + + def create_index_statement(self): + + localctx = PLpgSQLParser.Create_index_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 142, self.RULE_create_index_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2286 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.UNIQUE: + self.state = 2285 + self.match(PLpgSQLParser.UNIQUE) + + + self.state = 2288 + self.match(PLpgSQLParser.INDEX) + self.state = 2290 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONCURRENTLY: + self.state = 2289 + self.match(PLpgSQLParser.CONCURRENTLY) + + + self.state = 2293 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,225,self._ctx) + if la_ == 1: + self.state = 2292 + self.if_not_exists() + + + self.state = 2296 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 2295 + localctx.name = self.identifier() + + + self.state = 2298 + self.match(PLpgSQLParser.ON) + self.state = 2300 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 2299 + self.match(PLpgSQLParser.ONLY) + + + self.state = 2302 + localctx.table_name = self.schema_qualified_name() + self.state = 2303 + self.index_rest() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Index_restContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.method = None # IdentifierContext + + def index_sort(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_sortContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def including_index(self): + return self.getTypedRuleContext(PLpgSQLParser.Including_indexContext,0) + + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def table_space(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_spaceContext,0) + + + def index_where(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_whereContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_index_rest + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndex_rest" ): + listener.enterIndex_rest(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndex_rest" ): + listener.exitIndex_rest(self) + + + + + def index_rest(self): + + localctx = PLpgSQLParser.Index_restContext(self, self._ctx, self.state) + self.enterRule(localctx, 144, self.RULE_index_rest) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2307 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 2305 + self.match(PLpgSQLParser.USING) + self.state = 2306 + localctx.method = self.identifier() + + + self.state = 2309 + self.index_sort() + self.state = 2311 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INCLUDE: + self.state = 2310 + self.including_index() + + + self.state = 2314 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 2313 + self.with_storage_parameter() + + + self.state = 2317 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLESPACE: + self.state = 2316 + self.table_space() + + + self.state = 2320 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 2319 + self.index_where() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Index_sortContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def sort_specifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Sort_specifier_listContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_index_sort + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndex_sort" ): + listener.enterIndex_sort(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndex_sort" ): + listener.exitIndex_sort(self) + + + + + def index_sort(self): + + localctx = PLpgSQLParser.Index_sortContext(self, self._ctx, self.state) + self.enterRule(localctx, 146, self.RULE_index_sort) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2322 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2323 + self.sort_specifier_list() + self.state = 2324 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Including_indexContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INCLUDE(self): + return self.getToken(PLpgSQLParser.INCLUDE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_including_index + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIncluding_index" ): + listener.enterIncluding_index(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIncluding_index" ): + listener.exitIncluding_index(self) + + + + + def including_index(self): + + localctx = PLpgSQLParser.Including_indexContext(self, self._ctx, self.state) + self.enterRule(localctx, 148, self.RULE_including_index) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2326 + self.match(PLpgSQLParser.INCLUDE) + self.state = 2327 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2328 + self.identifier() + self.state = 2333 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2329 + self.match(PLpgSQLParser.COMMA) + self.state = 2330 + self.identifier() + self.state = 2335 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2336 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Index_whereContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_index_where + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndex_where" ): + listener.enterIndex_where(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndex_where" ): + listener.exitIndex_where(self) + + + + + def index_where(self): + + localctx = PLpgSQLParser.Index_whereContext(self, self._ctx, self.state) + self.enterRule(localctx, 150, self.RULE_index_where) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2338 + self.match(PLpgSQLParser.WHERE) + self.state = 2339 + self.vex(0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_extension_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.schema = None # IdentifierContext + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def CASCADE(self): + return self.getToken(PLpgSQLParser.CASCADE, 0) + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_extension_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_extension_statement" ): + listener.enterCreate_extension_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_extension_statement" ): + listener.exitCreate_extension_statement(self) + + + + + def create_extension_statement(self): + + localctx = PLpgSQLParser.Create_extension_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 152, self.RULE_create_extension_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2341 + self.match(PLpgSQLParser.EXTENSION) + self.state = 2343 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,234,self._ctx) + if la_ == 1: + self.state = 2342 + self.if_not_exists() + + + self.state = 2345 + localctx.name = self.identifier() + self.state = 2347 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 2346 + self.match(PLpgSQLParser.WITH) + + + self.state = 2351 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.SCHEMA: + self.state = 2349 + self.match(PLpgSQLParser.SCHEMA) + self.state = 2350 + localctx.schema = self.identifier() + + + self.state = 2358 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERSION: + self.state = 2353 + self.match(PLpgSQLParser.VERSION) + self.state = 2356 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2354 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 2355 + self.character_string() + pass + else: + raise NoViableAltException(self) + + + + self.state = 2365 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM: + self.state = 2360 + self.match(PLpgSQLParser.FROM) + self.state = 2363 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2361 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 2362 + self.character_string() + pass + else: + raise NoViableAltException(self) + + + + self.state = 2368 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE: + self.state = 2367 + self.match(PLpgSQLParser.CASCADE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_language_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def TRUSTED(self): + return self.getToken(PLpgSQLParser.TRUSTED, 0) + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def HANDLER(self): + return self.getToken(PLpgSQLParser.HANDLER, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def INLINE(self): + return self.getToken(PLpgSQLParser.INLINE, 0) + + def VALIDATOR(self): + return self.getToken(PLpgSQLParser.VALIDATOR, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_language_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_language_statement" ): + listener.enterCreate_language_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_language_statement" ): + listener.exitCreate_language_statement(self) + + + + + def create_language_statement(self): + + localctx = PLpgSQLParser.Create_language_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 154, self.RULE_create_language_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2372 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 2370 + self.match(PLpgSQLParser.OR) + self.state = 2371 + self.match(PLpgSQLParser.REPLACE) + + + self.state = 2375 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TRUSTED: + self.state = 2374 + self.match(PLpgSQLParser.TRUSTED) + + + self.state = 2378 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROCEDURAL: + self.state = 2377 + self.match(PLpgSQLParser.PROCEDURAL) + + + self.state = 2380 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 2381 + localctx.name = self.identifier() + self.state = 2392 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.HANDLER: + self.state = 2382 + self.match(PLpgSQLParser.HANDLER) + self.state = 2383 + self.schema_qualified_name() + self.state = 2386 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INLINE: + self.state = 2384 + self.match(PLpgSQLParser.INLINE) + self.state = 2385 + self.schema_qualified_name() + + + self.state = 2390 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VALIDATOR: + self.state = 2388 + self.match(PLpgSQLParser.VALIDATOR) + self.state = 2389 + self.schema_qualified_name() + + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_event_triggerContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def WHEN(self): + return self.getToken(PLpgSQLParser.WHEN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def IN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.IN) + else: + return self.getToken(PLpgSQLParser.IN, i) + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def AND(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.AND) + else: + return self.getToken(PLpgSQLParser.AND, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_event_trigger + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_event_trigger" ): + listener.enterCreate_event_trigger(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_event_trigger" ): + listener.exitCreate_event_trigger(self) + + + + + def create_event_trigger(self): + + localctx = PLpgSQLParser.Create_event_triggerContext(self, self._ctx, self.state) + self.enterRule(localctx, 156, self.RULE_create_event_trigger) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2394 + self.match(PLpgSQLParser.EVENT) + self.state = 2395 + self.match(PLpgSQLParser.TRIGGER) + self.state = 2396 + localctx.name = self.identifier() + self.state = 2397 + self.match(PLpgSQLParser.ON) + self.state = 2398 + self.identifier() + self.state = 2419 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHEN: + self.state = 2399 + self.match(PLpgSQLParser.WHEN) + self.state = 2415 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 2400 + self.schema_qualified_name() + self.state = 2401 + self.match(PLpgSQLParser.IN) + self.state = 2402 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2403 + self.character_string() + self.state = 2408 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2404 + self.match(PLpgSQLParser.COMMA) + self.state = 2405 + self.character_string() + self.state = 2410 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2411 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 2413 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AND: + self.state = 2412 + self.match(PLpgSQLParser.AND) + + + + else: + raise NoViableAltException(self) + self.state = 2417 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,250,self._ctx) + + + + self.state = 2421 + self.match(PLpgSQLParser.EXECUTE) + self.state = 2422 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2423 + self.vex(0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_type_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self._table_column_definition = None # Table_column_definitionContext + self.attrs = list() # of Table_column_definitionContexts + self._character_string = None # Character_stringContext + self.enums = list() # of Character_stringContexts + self.subtype_name = None # Data_typeContext + self.subtype_operator_class = None # IdentifierContext + self.collation = None # Schema_qualified_nameContext + self.canonical_function = None # Schema_qualified_nameContext + self.subtype_diff_function = None # Schema_qualified_nameContext + self.internallength = None # Signed_numerical_literalContext + self.input_function = None # Schema_qualified_nameContext + self.output_function = None # Schema_qualified_nameContext + self.receive_function = None # Schema_qualified_nameContext + self.send_function = None # Schema_qualified_nameContext + self.type_modifier_input_function = None # Schema_qualified_nameContext + self.type_modifier_output_function = None # Schema_qualified_nameContext + self.analyze_function = None # Schema_qualified_nameContext + self.alignment = None # Data_typeContext + self.storage = None # Token + self.like_type = None # Data_typeContext + self.category = None # Character_stringContext + self.preferred = None # Truth_valueContext + self.default_value = None # VexContext + self.element = None # Data_typeContext + self.delimiter = None # Character_stringContext + self.collatable = None # Truth_valueContext + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def INPUT(self): + return self.getToken(PLpgSQLParser.INPUT, 0) + + def EQUAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EQUAL) + else: + return self.getToken(PLpgSQLParser.EQUAL, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def OUTPUT(self): + return self.getToken(PLpgSQLParser.OUTPUT, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def ENUM(self): + return self.getToken(PLpgSQLParser.ENUM, 0) + + def RANGE(self): + return self.getToken(PLpgSQLParser.RANGE, 0) + + def INTERNALLENGTH(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.INTERNALLENGTH) + else: + return self.getToken(PLpgSQLParser.INTERNALLENGTH, i) + + def SUBTYPE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SUBTYPE) + else: + return self.getToken(PLpgSQLParser.SUBTYPE, i) + + def SUBTYPE_OPCLASS(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SUBTYPE_OPCLASS) + else: + return self.getToken(PLpgSQLParser.SUBTYPE_OPCLASS, i) + + def COLLATION(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COLLATION) + else: + return self.getToken(PLpgSQLParser.COLLATION, i) + + def CANONICAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.CANONICAL) + else: + return self.getToken(PLpgSQLParser.CANONICAL, i) + + def SUBTYPE_DIFF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SUBTYPE_DIFF) + else: + return self.getToken(PLpgSQLParser.SUBTYPE_DIFF, i) + + def VARIABLE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.VARIABLE) + else: + return self.getToken(PLpgSQLParser.VARIABLE, i) + + def RECEIVE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RECEIVE) + else: + return self.getToken(PLpgSQLParser.RECEIVE, i) + + def SEND(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SEND) + else: + return self.getToken(PLpgSQLParser.SEND, i) + + def TYPMOD_IN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.TYPMOD_IN) + else: + return self.getToken(PLpgSQLParser.TYPMOD_IN, i) + + def TYPMOD_OUT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.TYPMOD_OUT) + else: + return self.getToken(PLpgSQLParser.TYPMOD_OUT, i) + + def ANALYZE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ANALYZE) + else: + return self.getToken(PLpgSQLParser.ANALYZE, i) + + def PASSEDBYVALUE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.PASSEDBYVALUE) + else: + return self.getToken(PLpgSQLParser.PASSEDBYVALUE, i) + + def ALIGNMENT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ALIGNMENT) + else: + return self.getToken(PLpgSQLParser.ALIGNMENT, i) + + def STORAGE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.STORAGE) + else: + return self.getToken(PLpgSQLParser.STORAGE, i) + + def LIKE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LIKE) + else: + return self.getToken(PLpgSQLParser.LIKE, i) + + def CATEGORY(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.CATEGORY) + else: + return self.getToken(PLpgSQLParser.CATEGORY, i) + + def PREFERRED(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.PREFERRED) + else: + return self.getToken(PLpgSQLParser.PREFERRED, i) + + def DEFAULT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DEFAULT) + else: + return self.getToken(PLpgSQLParser.DEFAULT, i) + + def ELEMENT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ELEMENT) + else: + return self.getToken(PLpgSQLParser.ELEMENT, i) + + def DELIMITER(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DELIMITER) + else: + return self.getToken(PLpgSQLParser.DELIMITER, i) + + def COLLATABLE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COLLATABLE) + else: + return self.getToken(PLpgSQLParser.COLLATABLE, i) + + def table_column_definition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_column_definitionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_column_definitionContext,i) + + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def signed_numerical_literal(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Signed_numerical_literalContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Signed_numerical_literalContext,i) + + + def truth_value(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Truth_valueContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Truth_valueContext,i) + + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def PLAIN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.PLAIN) + else: + return self.getToken(PLpgSQLParser.PLAIN, i) + + def EXTERNAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EXTERNAL) + else: + return self.getToken(PLpgSQLParser.EXTERNAL, i) + + def EXTENDED(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EXTENDED) + else: + return self.getToken(PLpgSQLParser.EXTENDED, i) + + def MAIN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.MAIN) + else: + return self.getToken(PLpgSQLParser.MAIN, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_type_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_type_statement" ): + listener.enterCreate_type_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_type_statement" ): + listener.exitCreate_type_statement(self) + + + + + def create_type_statement(self): + + localctx = PLpgSQLParser.Create_type_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 158, self.RULE_create_type_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2425 + self.match(PLpgSQLParser.TYPE) + self.state = 2426 + localctx.name = self.schema_qualified_name() + self.state = 2574 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.AS]: + self.state = 2427 + self.match(PLpgSQLParser.AS) + self.state = 2496 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 2428 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2437 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 2429 + localctx._table_column_definition = self.table_column_definition() + localctx.attrs.append(localctx._table_column_definition) + self.state = 2434 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2430 + self.match(PLpgSQLParser.COMMA) + self.state = 2431 + localctx._table_column_definition = self.table_column_definition() + localctx.attrs.append(localctx._table_column_definition) + self.state = 2436 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 2439 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.ENUM]: + self.state = 2440 + self.match(PLpgSQLParser.ENUM) + self.state = 2441 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2450 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.Character_String_Literal or _la==PLpgSQLParser.BeginDollarStringConstant: + self.state = 2442 + localctx._character_string = self.character_string() + localctx.enums.append(localctx._character_string) + self.state = 2447 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2443 + self.match(PLpgSQLParser.COMMA) + self.state = 2444 + localctx._character_string = self.character_string() + localctx.enums.append(localctx._character_string) + self.state = 2449 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 2452 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.RANGE]: + self.state = 2453 + self.match(PLpgSQLParser.RANGE) + self.state = 2454 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2470 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SUBTYPE]: + self.state = 2455 + self.match(PLpgSQLParser.SUBTYPE) + self.state = 2456 + self.match(PLpgSQLParser.EQUAL) + self.state = 2457 + localctx.subtype_name = self.data_type() + pass + elif token in [PLpgSQLParser.SUBTYPE_OPCLASS]: + self.state = 2458 + self.match(PLpgSQLParser.SUBTYPE_OPCLASS) + self.state = 2459 + self.match(PLpgSQLParser.EQUAL) + self.state = 2460 + localctx.subtype_operator_class = self.identifier() + pass + elif token in [PLpgSQLParser.COLLATION]: + self.state = 2461 + self.match(PLpgSQLParser.COLLATION) + self.state = 2462 + self.match(PLpgSQLParser.EQUAL) + self.state = 2463 + localctx.collation = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.CANONICAL]: + self.state = 2464 + self.match(PLpgSQLParser.CANONICAL) + self.state = 2465 + self.match(PLpgSQLParser.EQUAL) + self.state = 2466 + localctx.canonical_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.SUBTYPE_DIFF]: + self.state = 2467 + self.match(PLpgSQLParser.SUBTYPE_DIFF) + self.state = 2468 + self.match(PLpgSQLParser.EQUAL) + self.state = 2469 + localctx.subtype_diff_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.COMMA, PLpgSQLParser.RIGHT_PAREN]: + pass + else: + pass + self.state = 2492 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2472 + self.match(PLpgSQLParser.COMMA) + self.state = 2488 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SUBTYPE]: + self.state = 2473 + self.match(PLpgSQLParser.SUBTYPE) + self.state = 2474 + self.match(PLpgSQLParser.EQUAL) + self.state = 2475 + localctx.subtype_name = self.data_type() + pass + elif token in [PLpgSQLParser.SUBTYPE_OPCLASS]: + self.state = 2476 + self.match(PLpgSQLParser.SUBTYPE_OPCLASS) + self.state = 2477 + self.match(PLpgSQLParser.EQUAL) + self.state = 2478 + localctx.subtype_operator_class = self.identifier() + pass + elif token in [PLpgSQLParser.COLLATION]: + self.state = 2479 + self.match(PLpgSQLParser.COLLATION) + self.state = 2480 + self.match(PLpgSQLParser.EQUAL) + self.state = 2481 + localctx.collation = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.CANONICAL]: + self.state = 2482 + self.match(PLpgSQLParser.CANONICAL) + self.state = 2483 + self.match(PLpgSQLParser.EQUAL) + self.state = 2484 + localctx.canonical_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.SUBTYPE_DIFF]: + self.state = 2485 + self.match(PLpgSQLParser.SUBTYPE_DIFF) + self.state = 2486 + self.match(PLpgSQLParser.EQUAL) + self.state = 2487 + localctx.subtype_diff_function = self.schema_qualified_name() + pass + else: + raise NoViableAltException(self) + + self.state = 2494 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2495 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 2498 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2506 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INTERNALLENGTH: + self.state = 2499 + self.match(PLpgSQLParser.INTERNALLENGTH) + self.state = 2500 + self.match(PLpgSQLParser.EQUAL) + self.state = 2503 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER]: + self.state = 2501 + localctx.internallength = self.signed_numerical_literal() + pass + elif token in [PLpgSQLParser.VARIABLE]: + self.state = 2502 + self.match(PLpgSQLParser.VARIABLE) + pass + else: + raise NoViableAltException(self) + + self.state = 2505 + self.match(PLpgSQLParser.COMMA) + + + self.state = 2508 + self.match(PLpgSQLParser.INPUT) + self.state = 2509 + self.match(PLpgSQLParser.EQUAL) + self.state = 2510 + localctx.input_function = self.schema_qualified_name() + self.state = 2511 + self.match(PLpgSQLParser.COMMA) + self.state = 2512 + self.match(PLpgSQLParser.OUTPUT) + self.state = 2513 + self.match(PLpgSQLParser.EQUAL) + self.state = 2514 + localctx.output_function = self.schema_qualified_name() + self.state = 2569 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2515 + self.match(PLpgSQLParser.COMMA) + self.state = 2565 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RECEIVE]: + self.state = 2516 + self.match(PLpgSQLParser.RECEIVE) + self.state = 2517 + self.match(PLpgSQLParser.EQUAL) + self.state = 2518 + localctx.receive_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.SEND]: + self.state = 2519 + self.match(PLpgSQLParser.SEND) + self.state = 2520 + self.match(PLpgSQLParser.EQUAL) + self.state = 2521 + localctx.send_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.TYPMOD_IN]: + self.state = 2522 + self.match(PLpgSQLParser.TYPMOD_IN) + self.state = 2523 + self.match(PLpgSQLParser.EQUAL) + self.state = 2524 + localctx.type_modifier_input_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.TYPMOD_OUT]: + self.state = 2525 + self.match(PLpgSQLParser.TYPMOD_OUT) + self.state = 2526 + self.match(PLpgSQLParser.EQUAL) + self.state = 2527 + localctx.type_modifier_output_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.ANALYZE]: + self.state = 2528 + self.match(PLpgSQLParser.ANALYZE) + self.state = 2529 + self.match(PLpgSQLParser.EQUAL) + self.state = 2530 + localctx.analyze_function = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.INTERNALLENGTH]: + self.state = 2531 + self.match(PLpgSQLParser.INTERNALLENGTH) + self.state = 2532 + self.match(PLpgSQLParser.EQUAL) + self.state = 2535 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER]: + self.state = 2533 + localctx.internallength = self.signed_numerical_literal() + pass + elif token in [PLpgSQLParser.VARIABLE]: + self.state = 2534 + self.match(PLpgSQLParser.VARIABLE) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.PASSEDBYVALUE]: + self.state = 2537 + self.match(PLpgSQLParser.PASSEDBYVALUE) + pass + elif token in [PLpgSQLParser.ALIGNMENT]: + self.state = 2538 + self.match(PLpgSQLParser.ALIGNMENT) + self.state = 2539 + self.match(PLpgSQLParser.EQUAL) + self.state = 2540 + localctx.alignment = self.data_type() + pass + elif token in [PLpgSQLParser.STORAGE]: + self.state = 2541 + self.match(PLpgSQLParser.STORAGE) + self.state = 2542 + self.match(PLpgSQLParser.EQUAL) + self.state = 2543 + localctx.storage = self._input.LT(1) + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.EXTERNAL or ((((_la - 460)) & ~0x3f) == 0 and ((1 << (_la - 460)) & ((1 << (PLpgSQLParser.EXTENDED - 460)) | (1 << (PLpgSQLParser.MAIN - 460)) | (1 << (PLpgSQLParser.PLAIN - 460)))) != 0)): + localctx.storage = self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.LIKE]: + self.state = 2544 + self.match(PLpgSQLParser.LIKE) + self.state = 2545 + self.match(PLpgSQLParser.EQUAL) + self.state = 2546 + localctx.like_type = self.data_type() + pass + elif token in [PLpgSQLParser.CATEGORY]: + self.state = 2547 + self.match(PLpgSQLParser.CATEGORY) + self.state = 2548 + self.match(PLpgSQLParser.EQUAL) + self.state = 2549 + localctx.category = self.character_string() + pass + elif token in [PLpgSQLParser.PREFERRED]: + self.state = 2550 + self.match(PLpgSQLParser.PREFERRED) + self.state = 2551 + self.match(PLpgSQLParser.EQUAL) + self.state = 2552 + localctx.preferred = self.truth_value() + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 2553 + self.match(PLpgSQLParser.DEFAULT) + self.state = 2554 + self.match(PLpgSQLParser.EQUAL) + self.state = 2555 + localctx.default_value = self.vex(0) + pass + elif token in [PLpgSQLParser.ELEMENT]: + self.state = 2556 + self.match(PLpgSQLParser.ELEMENT) + self.state = 2557 + self.match(PLpgSQLParser.EQUAL) + self.state = 2558 + localctx.element = self.data_type() + pass + elif token in [PLpgSQLParser.DELIMITER]: + self.state = 2559 + self.match(PLpgSQLParser.DELIMITER) + self.state = 2560 + self.match(PLpgSQLParser.EQUAL) + self.state = 2561 + localctx.delimiter = self.character_string() + pass + elif token in [PLpgSQLParser.COLLATABLE]: + self.state = 2562 + self.match(PLpgSQLParser.COLLATABLE) + self.state = 2563 + self.match(PLpgSQLParser.EQUAL) + self.state = 2564 + localctx.collatable = self.truth_value() + pass + else: + raise NoViableAltException(self) + + self.state = 2571 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2572 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.SEMI_COLON]: + pass + else: + pass + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_domain_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.dat_type = None # Data_typeContext + self.def_value = None # VexContext + self._domain_constraint = None # Domain_constraintContext + self.dom_constraint = list() # of Domain_constraintContexts + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def collate_identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Collate_identifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Collate_identifierContext,i) + + + def DEFAULT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DEFAULT) + else: + return self.getToken(PLpgSQLParser.DEFAULT, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def domain_constraint(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Domain_constraintContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Domain_constraintContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_domain_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_domain_statement" ): + listener.enterCreate_domain_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_domain_statement" ): + listener.exitCreate_domain_statement(self) + + + + + def create_domain_statement(self): + + localctx = PLpgSQLParser.Create_domain_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 160, self.RULE_create_domain_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2576 + self.match(PLpgSQLParser.DOMAIN) + self.state = 2577 + localctx.name = self.schema_qualified_name() + self.state = 2579 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 2578 + self.match(PLpgSQLParser.AS) + + + self.state = 2581 + localctx.dat_type = self.data_type() + self.state = 2588 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 378)) & ~0x3f) == 0 and ((1 << (_la - 378)) & ((1 << (PLpgSQLParser.CHECK - 378)) | (1 << (PLpgSQLParser.COLLATE - 378)) | (1 << (PLpgSQLParser.CONSTRAINT - 378)) | (1 << (PLpgSQLParser.DEFAULT - 378)) | (1 << (PLpgSQLParser.NOT - 378)) | (1 << (PLpgSQLParser.NULL - 378)))) != 0): + self.state = 2586 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.COLLATE]: + self.state = 2582 + self.collate_identifier() + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 2583 + self.match(PLpgSQLParser.DEFAULT) + self.state = 2584 + localctx.def_value = self.vex(0) + pass + elif token in [PLpgSQLParser.CHECK, PLpgSQLParser.CONSTRAINT, PLpgSQLParser.NOT, PLpgSQLParser.NULL]: + self.state = 2585 + localctx._domain_constraint = self.domain_constraint() + localctx.dom_constraint.append(localctx._domain_constraint) + pass + else: + raise NoViableAltException(self) + + self.state = 2590 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_server_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_server_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_server_statement" ): + listener.enterCreate_server_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_server_statement" ): + listener.exitCreate_server_statement(self) + + + + + def create_server_statement(self): + + localctx = PLpgSQLParser.Create_server_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 162, self.RULE_create_server_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2591 + self.match(PLpgSQLParser.SERVER) + self.state = 2593 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,269,self._ctx) + if la_ == 1: + self.state = 2592 + self.if_not_exists() + + + self.state = 2595 + self.identifier() + self.state = 2598 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TYPE: + self.state = 2596 + self.match(PLpgSQLParser.TYPE) + self.state = 2597 + self.character_string() + + + self.state = 2602 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERSION: + self.state = 2600 + self.match(PLpgSQLParser.VERSION) + self.state = 2601 + self.character_string() + + + self.state = 2604 + self.match(PLpgSQLParser.FOREIGN) + self.state = 2605 + self.match(PLpgSQLParser.DATA) + self.state = 2606 + self.match(PLpgSQLParser.WRAPPER) + self.state = 2607 + self.identifier() + self.state = 2609 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 2608 + self.define_foreign_options() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_fts_dictionaryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.template = None # Schema_qualified_nameContext + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def option_with_value(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Option_with_valueContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Option_with_valueContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_fts_dictionary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_fts_dictionary" ): + listener.enterCreate_fts_dictionary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_fts_dictionary" ): + listener.exitCreate_fts_dictionary(self) + + + + + def create_fts_dictionary(self): + + localctx = PLpgSQLParser.Create_fts_dictionaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 164, self.RULE_create_fts_dictionary) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2611 + self.match(PLpgSQLParser.TEXT) + self.state = 2612 + self.match(PLpgSQLParser.SEARCH) + self.state = 2613 + self.match(PLpgSQLParser.DICTIONARY) + self.state = 2614 + localctx.name = self.schema_qualified_name() + self.state = 2615 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2616 + self.match(PLpgSQLParser.TEMPLATE) + self.state = 2617 + self.match(PLpgSQLParser.EQUAL) + self.state = 2618 + localctx.template = self.schema_qualified_name() + self.state = 2623 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2619 + self.match(PLpgSQLParser.COMMA) + self.state = 2620 + self.option_with_value() + self.state = 2625 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2626 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Option_with_valueContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_option_with_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption_with_value" ): + listener.enterOption_with_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption_with_value" ): + listener.exitOption_with_value(self) + + + + + def option_with_value(self): + + localctx = PLpgSQLParser.Option_with_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 166, self.RULE_option_with_value) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2628 + self.identifier() + self.state = 2629 + self.match(PLpgSQLParser.EQUAL) + self.state = 2630 + self.vex(0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_fts_configurationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.parser_name = None # Schema_qualified_nameContext + self.config_name = None # Schema_qualified_nameContext + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def COPY(self): + return self.getToken(PLpgSQLParser.COPY, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_fts_configuration + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_fts_configuration" ): + listener.enterCreate_fts_configuration(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_fts_configuration" ): + listener.exitCreate_fts_configuration(self) + + + + + def create_fts_configuration(self): + + localctx = PLpgSQLParser.Create_fts_configurationContext(self, self._ctx, self.state) + self.enterRule(localctx, 168, self.RULE_create_fts_configuration) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2632 + self.match(PLpgSQLParser.TEXT) + self.state = 2633 + self.match(PLpgSQLParser.SEARCH) + self.state = 2634 + self.match(PLpgSQLParser.CONFIGURATION) + self.state = 2635 + localctx.name = self.schema_qualified_name() + self.state = 2636 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2643 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.PARSER]: + self.state = 2637 + self.match(PLpgSQLParser.PARSER) + self.state = 2638 + self.match(PLpgSQLParser.EQUAL) + self.state = 2639 + localctx.parser_name = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.COPY]: + self.state = 2640 + self.match(PLpgSQLParser.COPY) + self.state = 2641 + self.match(PLpgSQLParser.EQUAL) + self.state = 2642 + localctx.config_name = self.schema_qualified_name() + pass + else: + raise NoViableAltException(self) + + self.state = 2645 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_fts_templateContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.init_name = None # Schema_qualified_nameContext + self.lexize_name = None # Schema_qualified_nameContext + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def LEXIZE(self): + return self.getToken(PLpgSQLParser.LEXIZE, 0) + + def EQUAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EQUAL) + else: + return self.getToken(PLpgSQLParser.EQUAL, i) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def INIT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.INIT) + else: + return self.getToken(PLpgSQLParser.INIT, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_fts_template + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_fts_template" ): + listener.enterCreate_fts_template(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_fts_template" ): + listener.exitCreate_fts_template(self) + + + + + def create_fts_template(self): + + localctx = PLpgSQLParser.Create_fts_templateContext(self, self._ctx, self.state) + self.enterRule(localctx, 170, self.RULE_create_fts_template) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2647 + self.match(PLpgSQLParser.TEXT) + self.state = 2648 + self.match(PLpgSQLParser.SEARCH) + self.state = 2649 + self.match(PLpgSQLParser.TEMPLATE) + self.state = 2650 + localctx.name = self.schema_qualified_name() + self.state = 2651 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2657 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INIT: + self.state = 2652 + self.match(PLpgSQLParser.INIT) + self.state = 2653 + self.match(PLpgSQLParser.EQUAL) + self.state = 2654 + localctx.init_name = self.schema_qualified_name() + self.state = 2655 + self.match(PLpgSQLParser.COMMA) + + + self.state = 2659 + self.match(PLpgSQLParser.LEXIZE) + self.state = 2660 + self.match(PLpgSQLParser.EQUAL) + self.state = 2661 + localctx.lexize_name = self.schema_qualified_name() + self.state = 2666 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 2662 + self.match(PLpgSQLParser.COMMA) + self.state = 2663 + self.match(PLpgSQLParser.INIT) + self.state = 2664 + self.match(PLpgSQLParser.EQUAL) + self.state = 2665 + localctx.init_name = self.schema_qualified_name() + + + self.state = 2668 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_fts_parserContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.start_func = None # Schema_qualified_nameContext + self.gettoken_func = None # Schema_qualified_nameContext + self.end_func = None # Schema_qualified_nameContext + self.headline_func = None # Schema_qualified_nameContext + self.lextypes_func = None # Schema_qualified_nameContext + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def START(self): + return self.getToken(PLpgSQLParser.START, 0) + + def EQUAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EQUAL) + else: + return self.getToken(PLpgSQLParser.EQUAL, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def GETTOKEN(self): + return self.getToken(PLpgSQLParser.GETTOKEN, 0) + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def LEXTYPES(self): + return self.getToken(PLpgSQLParser.LEXTYPES, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def HEADLINE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.HEADLINE) + else: + return self.getToken(PLpgSQLParser.HEADLINE, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_fts_parser + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_fts_parser" ): + listener.enterCreate_fts_parser(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_fts_parser" ): + listener.exitCreate_fts_parser(self) + + + + + def create_fts_parser(self): + + localctx = PLpgSQLParser.Create_fts_parserContext(self, self._ctx, self.state) + self.enterRule(localctx, 172, self.RULE_create_fts_parser) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2670 + self.match(PLpgSQLParser.TEXT) + self.state = 2671 + self.match(PLpgSQLParser.SEARCH) + self.state = 2672 + self.match(PLpgSQLParser.PARSER) + self.state = 2673 + localctx.name = self.schema_qualified_name() + self.state = 2674 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2675 + self.match(PLpgSQLParser.START) + self.state = 2676 + self.match(PLpgSQLParser.EQUAL) + self.state = 2677 + localctx.start_func = self.schema_qualified_name() + self.state = 2678 + self.match(PLpgSQLParser.COMMA) + self.state = 2679 + self.match(PLpgSQLParser.GETTOKEN) + self.state = 2680 + self.match(PLpgSQLParser.EQUAL) + self.state = 2681 + localctx.gettoken_func = self.schema_qualified_name() + self.state = 2682 + self.match(PLpgSQLParser.COMMA) + self.state = 2683 + self.match(PLpgSQLParser.END) + self.state = 2684 + self.match(PLpgSQLParser.EQUAL) + self.state = 2685 + localctx.end_func = self.schema_qualified_name() + self.state = 2686 + self.match(PLpgSQLParser.COMMA) + self.state = 2692 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.HEADLINE: + self.state = 2687 + self.match(PLpgSQLParser.HEADLINE) + self.state = 2688 + self.match(PLpgSQLParser.EQUAL) + self.state = 2689 + localctx.headline_func = self.schema_qualified_name() + self.state = 2690 + self.match(PLpgSQLParser.COMMA) + + + self.state = 2694 + self.match(PLpgSQLParser.LEXTYPES) + self.state = 2695 + self.match(PLpgSQLParser.EQUAL) + self.state = 2696 + localctx.lextypes_func = self.schema_qualified_name() + self.state = 2701 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 2697 + self.match(PLpgSQLParser.COMMA) + self.state = 2698 + self.match(PLpgSQLParser.HEADLINE) + self.state = 2699 + self.match(PLpgSQLParser.EQUAL) + self.state = 2700 + localctx.headline_func = self.schema_qualified_name() + + + self.state = 2703 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_collationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def collation_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Collation_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Collation_optionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_collation + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_collation" ): + listener.enterCreate_collation(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_collation" ): + listener.exitCreate_collation(self) + + + + + def create_collation(self): + + localctx = PLpgSQLParser.Create_collationContext(self, self._ctx, self.state) + self.enterRule(localctx, 174, self.RULE_create_collation) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2705 + self.match(PLpgSQLParser.COLLATION) + self.state = 2707 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,279,self._ctx) + if la_ == 1: + self.state = 2706 + self.if_not_exists() + + + self.state = 2709 + localctx.name = self.schema_qualified_name() + self.state = 2724 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.FROM]: + self.state = 2710 + self.match(PLpgSQLParser.FROM) + self.state = 2711 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 2712 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2721 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VERSION or ((((_la - 457)) & ~0x3f) == 0 and ((1 << (_la - 457)) & ((1 << (PLpgSQLParser.DETERMINISTIC - 457)) | (1 << (PLpgSQLParser.LC_COLLATE - 457)) | (1 << (PLpgSQLParser.LC_CTYPE - 457)) | (1 << (PLpgSQLParser.LOCALE - 457)) | (1 << (PLpgSQLParser.PROVIDER - 457)))) != 0): + self.state = 2713 + self.collation_option() + self.state = 2718 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2714 + self.match(PLpgSQLParser.COMMA) + self.state = 2715 + self.collation_option() + self.state = 2720 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 2723 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_collationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def REFRESH(self): + return self.getToken(PLpgSQLParser.REFRESH, 0) + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_collation + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_collation" ): + listener.enterAlter_collation(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_collation" ): + listener.exitAlter_collation(self) + + + + + def alter_collation(self): + + localctx = PLpgSQLParser.Alter_collationContext(self, self._ctx, self.state) + self.enterRule(localctx, 176, self.RULE_alter_collation) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2726 + self.match(PLpgSQLParser.COLLATION) + self.state = 2727 + localctx.name = self.schema_qualified_name() + self.state = 2733 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.REFRESH]: + self.state = 2728 + self.match(PLpgSQLParser.REFRESH) + self.state = 2729 + self.match(PLpgSQLParser.VERSION) + pass + elif token in [PLpgSQLParser.RENAME]: + self.state = 2730 + self.rename_to() + pass + elif token in [PLpgSQLParser.OWNER]: + self.state = 2731 + self.owner_to() + pass + elif token in [PLpgSQLParser.SET]: + self.state = 2732 + self.set_schema() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Collation_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def LOCALE(self): + return self.getToken(PLpgSQLParser.LOCALE, 0) + + def LC_COLLATE(self): + return self.getToken(PLpgSQLParser.LC_COLLATE, 0) + + def LC_CTYPE(self): + return self.getToken(PLpgSQLParser.LC_CTYPE, 0) + + def PROVIDER(self): + return self.getToken(PLpgSQLParser.PROVIDER, 0) + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def DETERMINISTIC(self): + return self.getToken(PLpgSQLParser.DETERMINISTIC, 0) + + def boolean_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Boolean_valueContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_collation_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCollation_option" ): + listener.enterCollation_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCollation_option" ): + listener.exitCollation_option(self) + + + + + def collation_option(self): + + localctx = PLpgSQLParser.Collation_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 178, self.RULE_collation_option) + self._la = 0 # Token type + try: + self.state = 2744 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VERSION, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LOCALE, PLpgSQLParser.PROVIDER]: + self.enterOuterAlt(localctx, 1) + self.state = 2735 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.VERSION or ((((_la - 478)) & ~0x3f) == 0 and ((1 << (_la - 478)) & ((1 << (PLpgSQLParser.LC_COLLATE - 478)) | (1 << (PLpgSQLParser.LC_CTYPE - 478)) | (1 << (PLpgSQLParser.LOCALE - 478)) | (1 << (PLpgSQLParser.PROVIDER - 478)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2736 + self.match(PLpgSQLParser.EQUAL) + self.state = 2739 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 2737 + self.character_string() + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2738 + self.identifier() + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.DETERMINISTIC]: + self.enterOuterAlt(localctx, 2) + self.state = 2741 + self.match(PLpgSQLParser.DETERMINISTIC) + self.state = 2742 + self.match(PLpgSQLParser.EQUAL) + self.state = 2743 + self.boolean_value() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_user_mappingContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USER(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.USER) + else: + return self.getToken(PLpgSQLParser.USER, i) + + def MAPPING(self): + return self.getToken(PLpgSQLParser.MAPPING, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_user_mapping + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_user_mapping" ): + listener.enterCreate_user_mapping(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_user_mapping" ): + listener.exitCreate_user_mapping(self) + + + + + def create_user_mapping(self): + + localctx = PLpgSQLParser.Create_user_mappingContext(self, self._ctx, self.state) + self.enterRule(localctx, 180, self.RULE_create_user_mapping) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2746 + self.match(PLpgSQLParser.USER) + self.state = 2747 + self.match(PLpgSQLParser.MAPPING) + self.state = 2749 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IF: + self.state = 2748 + self.if_not_exists() + + + self.state = 2751 + self.match(PLpgSQLParser.FOR) + self.state = 2754 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.SESSION_USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2752 + self.user_name() + pass + elif token in [PLpgSQLParser.USER]: + self.state = 2753 + self.match(PLpgSQLParser.USER) + pass + else: + raise NoViableAltException(self) + + self.state = 2756 + self.match(PLpgSQLParser.SERVER) + self.state = 2757 + self.identifier() + self.state = 2759 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 2758 + self.define_foreign_options() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_user_mappingContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USER(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.USER) + else: + return self.getToken(PLpgSQLParser.USER, i) + + def MAPPING(self): + return self.getToken(PLpgSQLParser.MAPPING, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_user_mapping + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_user_mapping" ): + listener.enterAlter_user_mapping(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_user_mapping" ): + listener.exitAlter_user_mapping(self) + + + + + def alter_user_mapping(self): + + localctx = PLpgSQLParser.Alter_user_mappingContext(self, self._ctx, self.state) + self.enterRule(localctx, 182, self.RULE_alter_user_mapping) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2761 + self.match(PLpgSQLParser.USER) + self.state = 2762 + self.match(PLpgSQLParser.MAPPING) + self.state = 2763 + self.match(PLpgSQLParser.FOR) + self.state = 2766 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.SESSION_USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2764 + self.user_name() + pass + elif token in [PLpgSQLParser.USER]: + self.state = 2765 + self.match(PLpgSQLParser.USER) + pass + else: + raise NoViableAltException(self) + + self.state = 2768 + self.match(PLpgSQLParser.SERVER) + self.state = 2769 + self.identifier() + self.state = 2771 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 2770 + self.define_foreign_options() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_user_or_roleContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def alter_user_or_role_set_reset(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_user_or_role_set_resetContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def user_or_role_option_for_alter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.User_or_role_option_for_alterContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_option_for_alterContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_user_or_role + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_user_or_role" ): + listener.enterAlter_user_or_role(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_user_or_role" ): + listener.exitAlter_user_or_role(self) + + + + + def alter_user_or_role(self): + + localctx = PLpgSQLParser.Alter_user_or_roleContext(self, self._ctx, self.state) + self.enterRule(localctx, 184, self.RULE_alter_user_or_role) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2773 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.USER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2787 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,293,self._ctx) + if la_ == 1: + self.state = 2774 + self.alter_user_or_role_set_reset() + pass + + elif la_ == 2: + self.state = 2775 + self.identifier() + self.state = 2776 + self.rename_to() + pass + + elif la_ == 3: + self.state = 2778 + self.user_name() + self.state = 2780 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 2779 + self.match(PLpgSQLParser.WITH) + + + self.state = 2783 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2782 + self.user_or_role_option_for_alter() + self.state = 2785 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.CONNECTION or _la==PLpgSQLParser.ENCRYPTED or _la==PLpgSQLParser.INHERIT or _la==PLpgSQLParser.PASSWORD or _la==PLpgSQLParser.VALID or ((((_la - 446)) & ~0x3f) == 0 and ((1 << (_la - 446)) & ((1 << (PLpgSQLParser.BYPASSRLS - 446)) | (1 << (PLpgSQLParser.CREATEDB - 446)) | (1 << (PLpgSQLParser.CREATEROLE - 446)) | (1 << (PLpgSQLParser.LOGIN - 446)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 446)) | (1 << (PLpgSQLParser.NOCREATEDB - 446)) | (1 << (PLpgSQLParser.NOCREATEROLE - 446)) | (1 << (PLpgSQLParser.NOINHERIT - 446)) | (1 << (PLpgSQLParser.NOLOGIN - 446)) | (1 << (PLpgSQLParser.NOREPLICATION - 446)) | (1 << (PLpgSQLParser.NOSUPERUSER - 446)))) != 0) or _la==PLpgSQLParser.REPLICATION or _la==PLpgSQLParser.SUPERUSER): + break + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_user_or_role_set_resetContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def user_or_role_set_reset(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_set_resetContext,0) + + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_user_or_role_set_reset + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_user_or_role_set_reset" ): + listener.enterAlter_user_or_role_set_reset(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_user_or_role_set_reset" ): + listener.exitAlter_user_or_role_set_reset(self) + + + + + def alter_user_or_role_set_reset(self): + + localctx = PLpgSQLParser.Alter_user_or_role_set_resetContext(self, self._ctx, self.state) + self.enterRule(localctx, 186, self.RULE_alter_user_or_role_set_reset) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2791 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.SESSION_USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2789 + self.user_name() + pass + elif token in [PLpgSQLParser.ALL]: + self.state = 2790 + self.match(PLpgSQLParser.ALL) + pass + else: + raise NoViableAltException(self) + + self.state = 2796 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IN: + self.state = 2793 + self.match(PLpgSQLParser.IN) + self.state = 2794 + self.match(PLpgSQLParser.DATABASE) + self.state = 2795 + self.identifier() + + + self.state = 2798 + self.user_or_role_set_reset() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_or_role_set_resetContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def set_statement_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_statement_valueContext,0) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_or_role_set_reset + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_or_role_set_reset" ): + listener.enterUser_or_role_set_reset(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_or_role_set_reset" ): + listener.exitUser_or_role_set_reset(self) + + + + + def user_or_role_set_reset(self): + + localctx = PLpgSQLParser.User_or_role_set_resetContext(self, self._ctx, self.state) + self.enterRule(localctx, 188, self.RULE_user_or_role_set_reset) + self._la = 0 # Token type + try: + self.state = 2829 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,299,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2800 + self.match(PLpgSQLParser.SET) + self.state = 2804 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,296,self._ctx) + if la_ == 1: + self.state = 2801 + self.identifier() + self.state = 2802 + self.match(PLpgSQLParser.DOT) + + + self.state = 2806 + self.identifier() + self.state = 2807 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TO or _la==PLpgSQLParser.EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2808 + self.set_statement_value() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2810 + self.match(PLpgSQLParser.SET) + self.state = 2814 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,297,self._ctx) + if la_ == 1: + self.state = 2811 + self.identifier() + self.state = 2812 + self.match(PLpgSQLParser.DOT) + + + self.state = 2816 + self.identifier() + self.state = 2817 + self.match(PLpgSQLParser.FROM) + self.state = 2818 + self.match(PLpgSQLParser.CURRENT) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2820 + self.match(PLpgSQLParser.RESET) + self.state = 2824 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,298,self._ctx) + if la_ == 1: + self.state = 2821 + self.identifier() + self.state = 2822 + self.match(PLpgSQLParser.DOT) + + + self.state = 2826 + self.identifier() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2827 + self.match(PLpgSQLParser.RESET) + self.state = 2828 + self.match(PLpgSQLParser.ALL) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_groupContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def alter_group_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_group_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_group + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_group" ): + listener.enterAlter_group(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_group" ): + listener.exitAlter_group(self) + + + + + def alter_group(self): + + localctx = PLpgSQLParser.Alter_groupContext(self, self._ctx, self.state) + self.enterRule(localctx, 190, self.RULE_alter_group) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2831 + self.match(PLpgSQLParser.GROUP) + self.state = 2832 + self.alter_group_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_group_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_group_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_group_action" ): + listener.enterAlter_group_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_group_action" ): + listener.exitAlter_group_action(self) + + + + + def alter_group_action(self): + + localctx = PLpgSQLParser.Alter_group_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 192, self.RULE_alter_group_action) + self._la = 0 # Token type + try: + self.state = 2842 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,300,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2834 + localctx.name = self.identifier() + self.state = 2835 + self.rename_to() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2837 + self.user_name() + self.state = 2838 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ADD or _la==PLpgSQLParser.DROP): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2839 + self.match(PLpgSQLParser.USER) + self.state = 2840 + self.identifier_list() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_tablespaceContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def alter_tablespace_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_tablespace_actionContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_tablespace + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_tablespace" ): + listener.enterAlter_tablespace(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_tablespace" ): + listener.exitAlter_tablespace(self) + + + + + def alter_tablespace(self): + + localctx = PLpgSQLParser.Alter_tablespaceContext(self, self._ctx, self.state) + self.enterRule(localctx, 194, self.RULE_alter_tablespace) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2844 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 2845 + localctx.name = self.identifier() + self.state = 2846 + self.alter_tablespace_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_ownerContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def target_operator(self): + return self.getTypedRuleContext(PLpgSQLParser.Target_operatorContext,0) + + + def LARGE(self): + return self.getToken(PLpgSQLParser.LARGE, 0) + + def OBJECT(self): + return self.getToken(PLpgSQLParser.OBJECT, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_owner + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_owner" ): + listener.enterAlter_owner(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_owner" ): + listener.exitAlter_owner(self) + + + + + def alter_owner(self): + + localctx = PLpgSQLParser.Alter_ownerContext(self, self._ctx, self.state) + self.enterRule(localctx, 196, self.RULE_alter_owner) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2877 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.OPERATOR]: + self.state = 2848 + self.match(PLpgSQLParser.OPERATOR) + self.state = 2849 + self.target_operator() + pass + elif token in [PLpgSQLParser.LARGE]: + self.state = 2850 + self.match(PLpgSQLParser.LARGE) + self.state = 2851 + self.match(PLpgSQLParser.OBJECT) + self.state = 2852 + self.match(PLpgSQLParser.NUMBER_LITERAL) + pass + elif token in [PLpgSQLParser.AGGREGATE, PLpgSQLParser.FUNCTION, PLpgSQLParser.PROCEDURE]: + self.state = 2853 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.AGGREGATE or _la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2854 + localctx.name = self.schema_qualified_name() + self.state = 2855 + self.function_args() + pass + elif token in [PLpgSQLParser.DOMAIN, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.SCHEMA, PLpgSQLParser.SEQUENCE, PLpgSQLParser.TEXT, PLpgSQLParser.TYPE, PLpgSQLParser.VIEW]: + self.state = 2871 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,302,self._ctx) + if la_ == 1: + self.state = 2857 + self.match(PLpgSQLParser.TEXT) + self.state = 2858 + self.match(PLpgSQLParser.SEARCH) + self.state = 2859 + self.match(PLpgSQLParser.DICTIONARY) + pass + + elif la_ == 2: + self.state = 2860 + self.match(PLpgSQLParser.TEXT) + self.state = 2861 + self.match(PLpgSQLParser.SEARCH) + self.state = 2862 + self.match(PLpgSQLParser.CONFIGURATION) + pass + + elif la_ == 3: + self.state = 2863 + self.match(PLpgSQLParser.DOMAIN) + pass + + elif la_ == 4: + self.state = 2864 + self.match(PLpgSQLParser.SCHEMA) + pass + + elif la_ == 5: + self.state = 2865 + self.match(PLpgSQLParser.SEQUENCE) + pass + + elif la_ == 6: + self.state = 2866 + self.match(PLpgSQLParser.TYPE) + pass + + elif la_ == 7: + self.state = 2868 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 2867 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 2870 + self.match(PLpgSQLParser.VIEW) + pass + + + self.state = 2874 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,303,self._ctx) + if la_ == 1: + self.state = 2873 + self.if_exists() + + + self.state = 2876 + localctx.name = self.schema_qualified_name() + pass + else: + raise NoViableAltException(self) + + self.state = 2879 + self.owner_to() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_tablespace_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def option_with_value(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Option_with_valueContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Option_with_valueContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_tablespace_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_tablespace_action" ): + listener.enterAlter_tablespace_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_tablespace_action" ): + listener.exitAlter_tablespace_action(self) + + + + + def alter_tablespace_action(self): + + localctx = PLpgSQLParser.Alter_tablespace_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 198, self.RULE_alter_tablespace_action) + self._la = 0 # Token type + try: + self.state = 2900 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.enterOuterAlt(localctx, 1) + self.state = 2881 + self.rename_to() + pass + elif token in [PLpgSQLParser.OWNER]: + self.enterOuterAlt(localctx, 2) + self.state = 2882 + self.owner_to() + pass + elif token in [PLpgSQLParser.SET]: + self.enterOuterAlt(localctx, 3) + self.state = 2883 + self.match(PLpgSQLParser.SET) + self.state = 2884 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2885 + self.option_with_value() + self.state = 2890 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2886 + self.match(PLpgSQLParser.COMMA) + self.state = 2887 + self.option_with_value() + self.state = 2892 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2893 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.RESET]: + self.enterOuterAlt(localctx, 4) + self.state = 2895 + self.match(PLpgSQLParser.RESET) + self.state = 2896 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2897 + self.identifier_list() + self.state = 2898 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_statisticsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_statistics + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_statistics" ): + listener.enterAlter_statistics(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_statistics" ): + listener.exitAlter_statistics(self) + + + + + def alter_statistics(self): + + localctx = PLpgSQLParser.Alter_statisticsContext(self, self._ctx, self.state) + self.enterRule(localctx, 200, self.RULE_alter_statistics) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2902 + self.match(PLpgSQLParser.STATISTICS) + self.state = 2903 + localctx.name = self.schema_qualified_name() + self.state = 2907 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 2904 + self.rename_to() + pass + elif token in [PLpgSQLParser.SET]: + self.state = 2905 + self.set_schema() + pass + elif token in [PLpgSQLParser.OWNER]: + self.state = 2906 + self.owner_to() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_foreign_data_wrapperContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def alter_foreign_data_wrapper_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_foreign_data_wrapper_actionContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_foreign_data_wrapper + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_foreign_data_wrapper" ): + listener.enterAlter_foreign_data_wrapper(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_foreign_data_wrapper" ): + listener.exitAlter_foreign_data_wrapper(self) + + + + + def alter_foreign_data_wrapper(self): + + localctx = PLpgSQLParser.Alter_foreign_data_wrapperContext(self, self._ctx, self.state) + self.enterRule(localctx, 202, self.RULE_alter_foreign_data_wrapper) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2909 + self.match(PLpgSQLParser.FOREIGN) + self.state = 2910 + self.match(PLpgSQLParser.DATA) + self.state = 2911 + self.match(PLpgSQLParser.WRAPPER) + self.state = 2912 + localctx.name = self.identifier() + self.state = 2913 + self.alter_foreign_data_wrapper_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_foreign_data_wrapper_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def HANDLER(self): + return self.getToken(PLpgSQLParser.HANDLER, 0) + + def schema_qualified_name_nontype(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_name_nontypeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_name_nontypeContext,i) + + + def NO(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NO) + else: + return self.getToken(PLpgSQLParser.NO, i) + + def VALIDATOR(self): + return self.getToken(PLpgSQLParser.VALIDATOR, 0) + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_foreign_data_wrapper_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_foreign_data_wrapper_action" ): + listener.enterAlter_foreign_data_wrapper_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_foreign_data_wrapper_action" ): + listener.exitAlter_foreign_data_wrapper_action(self) + + + + + def alter_foreign_data_wrapper_action(self): + + localctx = PLpgSQLParser.Alter_foreign_data_wrapper_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 204, self.RULE_alter_foreign_data_wrapper_action) + self._la = 0 # Token type + try: + self.state = 2932 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.EOF, PLpgSQLParser.HANDLER, PLpgSQLParser.NO, PLpgSQLParser.OPTIONS, PLpgSQLParser.VALIDATOR, PLpgSQLParser.SEMI_COLON]: + self.enterOuterAlt(localctx, 1) + self.state = 2919 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,308,self._ctx) + if la_ == 1: + self.state = 2915 + self.match(PLpgSQLParser.HANDLER) + self.state = 2916 + self.schema_qualified_name_nontype() + + elif la_ == 2: + self.state = 2917 + self.match(PLpgSQLParser.NO) + self.state = 2918 + self.match(PLpgSQLParser.HANDLER) + + + self.state = 2925 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VALIDATOR]: + self.state = 2921 + self.match(PLpgSQLParser.VALIDATOR) + self.state = 2922 + self.schema_qualified_name_nontype() + pass + elif token in [PLpgSQLParser.NO]: + self.state = 2923 + self.match(PLpgSQLParser.NO) + self.state = 2924 + self.match(PLpgSQLParser.VALIDATOR) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.OPTIONS, PLpgSQLParser.SEMI_COLON]: + pass + else: + pass + self.state = 2928 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 2927 + self.define_foreign_options() + + + pass + elif token in [PLpgSQLParser.OWNER]: + self.enterOuterAlt(localctx, 2) + self.state = 2930 + self.owner_to() + pass + elif token in [PLpgSQLParser.RENAME]: + self.enterOuterAlt(localctx, 3) + self.state = 2931 + self.rename_to() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_operator_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def target_operator(self): + return self.getTypedRuleContext(PLpgSQLParser.Target_operatorContext,0) + + + def alter_operator_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_operator_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_operator_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_operator_statement" ): + listener.enterAlter_operator_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_operator_statement" ): + listener.exitAlter_operator_statement(self) + + + + + def alter_operator_statement(self): + + localctx = PLpgSQLParser.Alter_operator_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 206, self.RULE_alter_operator_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2934 + self.match(PLpgSQLParser.OPERATOR) + self.state = 2935 + self.target_operator() + self.state = 2936 + self.alter_operator_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_operator_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def operator_set_restrict_join(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Operator_set_restrict_joinContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Operator_set_restrict_joinContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_operator_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_operator_action" ): + listener.enterAlter_operator_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_operator_action" ): + listener.exitAlter_operator_action(self) + + + + + def alter_operator_action(self): + + localctx = PLpgSQLParser.Alter_operator_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 208, self.RULE_alter_operator_action) + self._la = 0 # Token type + try: + self.state = 2951 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,313,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2938 + self.set_schema() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2939 + self.match(PLpgSQLParser.SET) + self.state = 2940 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 2941 + self.operator_set_restrict_join() + self.state = 2946 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2942 + self.match(PLpgSQLParser.COMMA) + self.state = 2943 + self.operator_set_restrict_join() + self.state = 2948 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2949 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Operator_set_restrict_joinContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def RESTRICT(self): + return self.getToken(PLpgSQLParser.RESTRICT, 0) + + def JOIN(self): + return self.getToken(PLpgSQLParser.JOIN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_operator_set_restrict_join + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOperator_set_restrict_join" ): + listener.enterOperator_set_restrict_join(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOperator_set_restrict_join" ): + listener.exitOperator_set_restrict_join(self) + + + + + def operator_set_restrict_join(self): + + localctx = PLpgSQLParser.Operator_set_restrict_joinContext(self, self._ctx, self.state) + self.enterRule(localctx, 210, self.RULE_operator_set_restrict_join) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2953 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.RESTRICT or _la==PLpgSQLParser.JOIN): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2954 + self.match(PLpgSQLParser.EQUAL) + self.state = 2955 + self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_user_mappingContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USER(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.USER) + else: + return self.getToken(PLpgSQLParser.USER, i) + + def MAPPING(self): + return self.getToken(PLpgSQLParser.MAPPING, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_user_mapping + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_user_mapping" ): + listener.enterDrop_user_mapping(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_user_mapping" ): + listener.exitDrop_user_mapping(self) + + + + + def drop_user_mapping(self): + + localctx = PLpgSQLParser.Drop_user_mappingContext(self, self._ctx, self.state) + self.enterRule(localctx, 212, self.RULE_drop_user_mapping) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2957 + self.match(PLpgSQLParser.USER) + self.state = 2958 + self.match(PLpgSQLParser.MAPPING) + self.state = 2960 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IF: + self.state = 2959 + self.if_exists() + + + self.state = 2962 + self.match(PLpgSQLParser.FOR) + self.state = 2965 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.SESSION_USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 2963 + self.user_name() + pass + elif token in [PLpgSQLParser.USER]: + self.state = 2964 + self.match(PLpgSQLParser.USER) + pass + else: + raise NoViableAltException(self) + + self.state = 2967 + self.match(PLpgSQLParser.SERVER) + self.state = 2968 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_ownedContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OWNED(self): + return self.getToken(PLpgSQLParser.OWNED, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def user_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.User_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_owned + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_owned" ): + listener.enterDrop_owned(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_owned" ): + listener.exitDrop_owned(self) + + + + + def drop_owned(self): + + localctx = PLpgSQLParser.Drop_ownedContext(self, self._ctx, self.state) + self.enterRule(localctx, 214, self.RULE_drop_owned) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2970 + self.match(PLpgSQLParser.OWNED) + self.state = 2971 + self.match(PLpgSQLParser.BY) + self.state = 2972 + self.user_name() + self.state = 2977 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2973 + self.match(PLpgSQLParser.COMMA) + self.state = 2974 + self.user_name() + self.state = 2979 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2981 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 2980 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_operator_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def target_operator(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Target_operatorContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Target_operatorContext,i) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_operator_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_operator_statement" ): + listener.enterDrop_operator_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_operator_statement" ): + listener.exitDrop_operator_statement(self) + + + + + def drop_operator_statement(self): + + localctx = PLpgSQLParser.Drop_operator_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 216, self.RULE_drop_operator_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2983 + self.match(PLpgSQLParser.OPERATOR) + self.state = 2985 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,318,self._ctx) + if la_ == 1: + self.state = 2984 + self.if_exists() + + + self.state = 2987 + self.target_operator() + self.state = 2992 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 2988 + self.match(PLpgSQLParser.COMMA) + self.state = 2989 + self.target_operator() + self.state = 2994 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2996 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 2995 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Target_operatorContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Operator_nameContext + self.left_type = None # Data_typeContext + self.right_type = None # Data_typeContext + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def operator_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Operator_nameContext,0) + + + def NONE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NONE) + else: + return self.getToken(PLpgSQLParser.NONE, i) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_target_operator + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTarget_operator" ): + listener.enterTarget_operator(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTarget_operator" ): + listener.exitTarget_operator(self) + + + + + def target_operator(self): + + localctx = PLpgSQLParser.Target_operatorContext(self, self._ctx, self.state) + self.enterRule(localctx, 218, self.RULE_target_operator) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2998 + localctx.name = self.operator_name() + self.state = 2999 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3002 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,321,self._ctx) + if la_ == 1: + self.state = 3000 + localctx.left_type = self.data_type() + pass + + elif la_ == 2: + self.state = 3001 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 3004 + self.match(PLpgSQLParser.COMMA) + self.state = 3007 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,322,self._ctx) + if la_ == 1: + self.state = 3005 + localctx.right_type = self.data_type() + pass + + elif la_ == 2: + self.state = 3006 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 3009 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Domain_constraintContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def CHECK(self): + return self.getToken(PLpgSQLParser.CHECK, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_domain_constraint + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDomain_constraint" ): + listener.enterDomain_constraint(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDomain_constraint" ): + listener.exitDomain_constraint(self) + + + + + def domain_constraint(self): + + localctx = PLpgSQLParser.Domain_constraintContext(self, self._ctx, self.state) + self.enterRule(localctx, 220, self.RULE_domain_constraint) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3013 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONSTRAINT: + self.state = 3011 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 3012 + localctx.name = self.identifier() + + + self.state = 3024 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CHECK]: + self.state = 3015 + self.match(PLpgSQLParser.CHECK) + self.state = 3016 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3017 + self.vex(0) + self.state = 3018 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.NOT, PLpgSQLParser.NULL]: + self.state = 3021 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 3020 + self.match(PLpgSQLParser.NOT) + + + self.state = 3023 + self.match(PLpgSQLParser.NULL) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_transform_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRANSFORM(self): + return self.getToken(PLpgSQLParser.TRANSFORM, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def SQL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SQL) + else: + return self.getToken(PLpgSQLParser.SQL, i) + + def WITH(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WITH) + else: + return self.getToken(PLpgSQLParser.WITH, i) + + def FUNCTION(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.FUNCTION) + else: + return self.getToken(PLpgSQLParser.FUNCTION, i) + + def function_parameters(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_parametersContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_parametersContext,i) + + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_transform_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_transform_statement" ): + listener.enterCreate_transform_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_transform_statement" ): + listener.exitCreate_transform_statement(self) + + + + + def create_transform_statement(self): + + localctx = PLpgSQLParser.Create_transform_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 222, self.RULE_create_transform_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3028 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 3026 + self.match(PLpgSQLParser.OR) + self.state = 3027 + self.match(PLpgSQLParser.REPLACE) + + + self.state = 3030 + self.match(PLpgSQLParser.TRANSFORM) + self.state = 3031 + self.match(PLpgSQLParser.FOR) + self.state = 3032 + self.data_type() + self.state = 3033 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 3034 + self.identifier() + self.state = 3035 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3036 + self.match(PLpgSQLParser.FROM) + self.state = 3037 + self.match(PLpgSQLParser.SQL) + self.state = 3038 + self.match(PLpgSQLParser.WITH) + self.state = 3039 + self.match(PLpgSQLParser.FUNCTION) + self.state = 3040 + self.function_parameters() + self.state = 3041 + self.match(PLpgSQLParser.COMMA) + self.state = 3042 + self.match(PLpgSQLParser.TO) + self.state = 3043 + self.match(PLpgSQLParser.SQL) + self.state = 3044 + self.match(PLpgSQLParser.WITH) + self.state = 3045 + self.match(PLpgSQLParser.FUNCTION) + self.state = 3046 + self.function_parameters() + self.state = 3047 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_access_methodContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ACCESS(self): + return self.getToken(PLpgSQLParser.ACCESS, 0) + + def METHOD(self): + return self.getToken(PLpgSQLParser.METHOD, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def HANDLER(self): + return self.getToken(PLpgSQLParser.HANDLER, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_access_method + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_access_method" ): + listener.enterCreate_access_method(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_access_method" ): + listener.exitCreate_access_method(self) + + + + + def create_access_method(self): + + localctx = PLpgSQLParser.Create_access_methodContext(self, self._ctx, self.state) + self.enterRule(localctx, 224, self.RULE_create_access_method) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3049 + self.match(PLpgSQLParser.ACCESS) + self.state = 3050 + self.match(PLpgSQLParser.METHOD) + self.state = 3051 + self.identifier() + self.state = 3052 + self.match(PLpgSQLParser.TYPE) + self.state = 3053 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.INDEX or _la==PLpgSQLParser.TABLE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3054 + self.match(PLpgSQLParser.HANDLER) + self.state = 3055 + self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_user_or_roleContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def user_or_role_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.User_or_role_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_optionContext,i) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_user_or_role + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_user_or_role" ): + listener.enterCreate_user_or_role(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_user_or_role" ): + listener.exitCreate_user_or_role(self) + + + + + def create_user_or_role(self): + + localctx = PLpgSQLParser.Create_user_or_roleContext(self, self._ctx, self.state) + self.enterRule(localctx, 226, self.RULE_create_user_or_role) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3057 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.USER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3058 + localctx.name = self.identifier() + self.state = 3069 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ADMIN or _la==PLpgSQLParser.CONNECTION or _la==PLpgSQLParser.ENCRYPTED or _la==PLpgSQLParser.INHERIT or _la==PLpgSQLParser.PASSWORD or _la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.SYSID or _la==PLpgSQLParser.VALID or ((((_la - 405)) & ~0x3f) == 0 and ((1 << (_la - 405)) & ((1 << (PLpgSQLParser.IN - 405)) | (1 << (PLpgSQLParser.USER - 405)) | (1 << (PLpgSQLParser.WITH - 405)) | (1 << (PLpgSQLParser.BYPASSRLS - 405)) | (1 << (PLpgSQLParser.CREATEDB - 405)) | (1 << (PLpgSQLParser.CREATEROLE - 405)))) != 0) or ((((_la - 485)) & ~0x3f) == 0 and ((1 << (_la - 485)) & ((1 << (PLpgSQLParser.LOGIN - 485)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 485)) | (1 << (PLpgSQLParser.NOCREATEDB - 485)) | (1 << (PLpgSQLParser.NOCREATEROLE - 485)) | (1 << (PLpgSQLParser.NOINHERIT - 485)) | (1 << (PLpgSQLParser.NOLOGIN - 485)) | (1 << (PLpgSQLParser.NOREPLICATION - 485)) | (1 << (PLpgSQLParser.NOSUPERUSER - 485)) | (1 << (PLpgSQLParser.REPLICATION - 485)) | (1 << (PLpgSQLParser.SUPERUSER - 485)))) != 0): + self.state = 3060 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 3059 + self.match(PLpgSQLParser.WITH) + + + self.state = 3062 + self.user_or_role_option() + self.state = 3066 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.ADMIN or _la==PLpgSQLParser.CONNECTION or _la==PLpgSQLParser.ENCRYPTED or _la==PLpgSQLParser.INHERIT or _la==PLpgSQLParser.PASSWORD or _la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.SYSID or _la==PLpgSQLParser.VALID or ((((_la - 405)) & ~0x3f) == 0 and ((1 << (_la - 405)) & ((1 << (PLpgSQLParser.IN - 405)) | (1 << (PLpgSQLParser.USER - 405)) | (1 << (PLpgSQLParser.BYPASSRLS - 405)) | (1 << (PLpgSQLParser.CREATEDB - 405)) | (1 << (PLpgSQLParser.CREATEROLE - 405)))) != 0) or ((((_la - 485)) & ~0x3f) == 0 and ((1 << (_la - 485)) & ((1 << (PLpgSQLParser.LOGIN - 485)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 485)) | (1 << (PLpgSQLParser.NOCREATEDB - 485)) | (1 << (PLpgSQLParser.NOCREATEROLE - 485)) | (1 << (PLpgSQLParser.NOINHERIT - 485)) | (1 << (PLpgSQLParser.NOLOGIN - 485)) | (1 << (PLpgSQLParser.NOREPLICATION - 485)) | (1 << (PLpgSQLParser.NOSUPERUSER - 485)) | (1 << (PLpgSQLParser.REPLICATION - 485)) | (1 << (PLpgSQLParser.SUPERUSER - 485)))) != 0): + self.state = 3063 + self.user_or_role_option() + self.state = 3068 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_or_role_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def user_or_role_or_group_common_option(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_or_group_common_optionContext,0) + + + def user_or_role_common_option(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_common_optionContext,0) + + + def user_or_role_or_group_option_for_create(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_or_group_option_for_createContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_or_role_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_or_role_option" ): + listener.enterUser_or_role_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_or_role_option" ): + listener.exitUser_or_role_option(self) + + + + + def user_or_role_option(self): + + localctx = PLpgSQLParser.User_or_role_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 228, self.RULE_user_or_role_option) + try: + self.state = 3074 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ENCRYPTED, PLpgSQLParser.INHERIT, PLpgSQLParser.PASSWORD, PLpgSQLParser.VALID, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.LOGIN, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.SUPERUSER]: + self.enterOuterAlt(localctx, 1) + self.state = 3071 + self.user_or_role_or_group_common_option() + pass + elif token in [PLpgSQLParser.CONNECTION, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.REPLICATION]: + self.enterOuterAlt(localctx, 2) + self.state = 3072 + self.user_or_role_common_option() + pass + elif token in [PLpgSQLParser.ADMIN, PLpgSQLParser.ROLE, PLpgSQLParser.SYSID, PLpgSQLParser.IN, PLpgSQLParser.USER]: + self.enterOuterAlt(localctx, 3) + self.state = 3073 + self.user_or_role_or_group_option_for_create() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_or_role_option_for_alterContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def user_or_role_or_group_common_option(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_or_group_common_optionContext,0) + + + def user_or_role_common_option(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_common_optionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_or_role_option_for_alter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_or_role_option_for_alter" ): + listener.enterUser_or_role_option_for_alter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_or_role_option_for_alter" ): + listener.exitUser_or_role_option_for_alter(self) + + + + + def user_or_role_option_for_alter(self): + + localctx = PLpgSQLParser.User_or_role_option_for_alterContext(self, self._ctx, self.state) + self.enterRule(localctx, 230, self.RULE_user_or_role_option_for_alter) + try: + self.state = 3078 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ENCRYPTED, PLpgSQLParser.INHERIT, PLpgSQLParser.PASSWORD, PLpgSQLParser.VALID, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.LOGIN, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.SUPERUSER]: + self.enterOuterAlt(localctx, 1) + self.state = 3076 + self.user_or_role_or_group_common_option() + pass + elif token in [PLpgSQLParser.CONNECTION, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.REPLICATION]: + self.enterOuterAlt(localctx, 2) + self.state = 3077 + self.user_or_role_common_option() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_or_role_or_group_common_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.password = None # Token + self.date_time = None # Token + + def SUPERUSER(self): + return self.getToken(PLpgSQLParser.SUPERUSER, 0) + + def NOSUPERUSER(self): + return self.getToken(PLpgSQLParser.NOSUPERUSER, 0) + + def CREATEDB(self): + return self.getToken(PLpgSQLParser.CREATEDB, 0) + + def NOCREATEDB(self): + return self.getToken(PLpgSQLParser.NOCREATEDB, 0) + + def CREATEROLE(self): + return self.getToken(PLpgSQLParser.CREATEROLE, 0) + + def NOCREATEROLE(self): + return self.getToken(PLpgSQLParser.NOCREATEROLE, 0) + + def INHERIT(self): + return self.getToken(PLpgSQLParser.INHERIT, 0) + + def NOINHERIT(self): + return self.getToken(PLpgSQLParser.NOINHERIT, 0) + + def LOGIN(self): + return self.getToken(PLpgSQLParser.LOGIN, 0) + + def NOLOGIN(self): + return self.getToken(PLpgSQLParser.NOLOGIN, 0) + + def PASSWORD(self): + return self.getToken(PLpgSQLParser.PASSWORD, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def ENCRYPTED(self): + return self.getToken(PLpgSQLParser.ENCRYPTED, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def VALID(self): + return self.getToken(PLpgSQLParser.VALID, 0) + + def UNTIL(self): + return self.getToken(PLpgSQLParser.UNTIL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_or_role_or_group_common_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_or_role_or_group_common_option" ): + listener.enterUser_or_role_or_group_common_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_or_role_or_group_common_option" ): + listener.exitUser_or_role_or_group_common_option(self) + + + + + def user_or_role_or_group_common_option(self): + + localctx = PLpgSQLParser.User_or_role_or_group_common_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 232, self.RULE_user_or_role_or_group_common_option) + self._la = 0 # Token type + try: + self.state = 3101 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SUPERUSER]: + self.enterOuterAlt(localctx, 1) + self.state = 3080 + self.match(PLpgSQLParser.SUPERUSER) + pass + elif token in [PLpgSQLParser.NOSUPERUSER]: + self.enterOuterAlt(localctx, 2) + self.state = 3081 + self.match(PLpgSQLParser.NOSUPERUSER) + pass + elif token in [PLpgSQLParser.CREATEDB]: + self.enterOuterAlt(localctx, 3) + self.state = 3082 + self.match(PLpgSQLParser.CREATEDB) + pass + elif token in [PLpgSQLParser.NOCREATEDB]: + self.enterOuterAlt(localctx, 4) + self.state = 3083 + self.match(PLpgSQLParser.NOCREATEDB) + pass + elif token in [PLpgSQLParser.CREATEROLE]: + self.enterOuterAlt(localctx, 5) + self.state = 3084 + self.match(PLpgSQLParser.CREATEROLE) + pass + elif token in [PLpgSQLParser.NOCREATEROLE]: + self.enterOuterAlt(localctx, 6) + self.state = 3085 + self.match(PLpgSQLParser.NOCREATEROLE) + pass + elif token in [PLpgSQLParser.INHERIT]: + self.enterOuterAlt(localctx, 7) + self.state = 3086 + self.match(PLpgSQLParser.INHERIT) + pass + elif token in [PLpgSQLParser.NOINHERIT]: + self.enterOuterAlt(localctx, 8) + self.state = 3087 + self.match(PLpgSQLParser.NOINHERIT) + pass + elif token in [PLpgSQLParser.LOGIN]: + self.enterOuterAlt(localctx, 9) + self.state = 3088 + self.match(PLpgSQLParser.LOGIN) + pass + elif token in [PLpgSQLParser.NOLOGIN]: + self.enterOuterAlt(localctx, 10) + self.state = 3089 + self.match(PLpgSQLParser.NOLOGIN) + pass + elif token in [PLpgSQLParser.ENCRYPTED, PLpgSQLParser.PASSWORD]: + self.enterOuterAlt(localctx, 11) + self.state = 3091 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ENCRYPTED: + self.state = 3090 + self.match(PLpgSQLParser.ENCRYPTED) + + + self.state = 3093 + self.match(PLpgSQLParser.PASSWORD) + self.state = 3096 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Character_String_Literal]: + self.state = 3094 + localctx.password = self.match(PLpgSQLParser.Character_String_Literal) + pass + elif token in [PLpgSQLParser.NULL]: + self.state = 3095 + self.match(PLpgSQLParser.NULL) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.VALID]: + self.enterOuterAlt(localctx, 12) + self.state = 3098 + self.match(PLpgSQLParser.VALID) + self.state = 3099 + self.match(PLpgSQLParser.UNTIL) + self.state = 3100 + localctx.date_time = self.match(PLpgSQLParser.Character_String_Literal) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_or_role_common_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPLICATION(self): + return self.getToken(PLpgSQLParser.REPLICATION, 0) + + def NOREPLICATION(self): + return self.getToken(PLpgSQLParser.NOREPLICATION, 0) + + def BYPASSRLS(self): + return self.getToken(PLpgSQLParser.BYPASSRLS, 0) + + def NOBYPASSRLS(self): + return self.getToken(PLpgSQLParser.NOBYPASSRLS, 0) + + def CONNECTION(self): + return self.getToken(PLpgSQLParser.CONNECTION, 0) + + def LIMIT(self): + return self.getToken(PLpgSQLParser.LIMIT, 0) + + def signed_number_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Signed_number_literalContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_or_role_common_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_or_role_common_option" ): + listener.enterUser_or_role_common_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_or_role_common_option" ): + listener.exitUser_or_role_common_option(self) + + + + + def user_or_role_common_option(self): + + localctx = PLpgSQLParser.User_or_role_common_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 234, self.RULE_user_or_role_common_option) + try: + self.state = 3110 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.REPLICATION]: + self.enterOuterAlt(localctx, 1) + self.state = 3103 + self.match(PLpgSQLParser.REPLICATION) + pass + elif token in [PLpgSQLParser.NOREPLICATION]: + self.enterOuterAlt(localctx, 2) + self.state = 3104 + self.match(PLpgSQLParser.NOREPLICATION) + pass + elif token in [PLpgSQLParser.BYPASSRLS]: + self.enterOuterAlt(localctx, 3) + self.state = 3105 + self.match(PLpgSQLParser.BYPASSRLS) + pass + elif token in [PLpgSQLParser.NOBYPASSRLS]: + self.enterOuterAlt(localctx, 4) + self.state = 3106 + self.match(PLpgSQLParser.NOBYPASSRLS) + pass + elif token in [PLpgSQLParser.CONNECTION]: + self.enterOuterAlt(localctx, 5) + self.state = 3107 + self.match(PLpgSQLParser.CONNECTION) + self.state = 3108 + self.match(PLpgSQLParser.LIMIT) + self.state = 3109 + self.signed_number_literal() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class User_or_role_or_group_option_for_createContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SYSID(self): + return self.getToken(PLpgSQLParser.SYSID, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def ADMIN(self): + return self.getToken(PLpgSQLParser.ADMIN, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_user_or_role_or_group_option_for_create + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUser_or_role_or_group_option_for_create" ): + listener.enterUser_or_role_or_group_option_for_create(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUser_or_role_or_group_option_for_create" ): + listener.exitUser_or_role_or_group_option_for_create(self) + + + + + def user_or_role_or_group_option_for_create(self): + + localctx = PLpgSQLParser.User_or_role_or_group_option_for_createContext(self, self._ctx, self.state) + self.enterRule(localctx, 236, self.RULE_user_or_role_or_group_option_for_create) + try: + self.state = 3124 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SYSID]: + self.enterOuterAlt(localctx, 1) + self.state = 3112 + self.match(PLpgSQLParser.SYSID) + self.state = 3113 + self.vex(0) + pass + elif token in [PLpgSQLParser.ADMIN, PLpgSQLParser.ROLE, PLpgSQLParser.IN, PLpgSQLParser.USER]: + self.enterOuterAlt(localctx, 2) + self.state = 3121 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,336,self._ctx) + if la_ == 1: + self.state = 3114 + self.match(PLpgSQLParser.IN) + self.state = 3115 + self.match(PLpgSQLParser.ROLE) + pass + + elif la_ == 2: + self.state = 3116 + self.match(PLpgSQLParser.IN) + self.state = 3117 + self.match(PLpgSQLParser.GROUP) + pass + + elif la_ == 3: + self.state = 3118 + self.match(PLpgSQLParser.ROLE) + pass + + elif la_ == 4: + self.state = 3119 + self.match(PLpgSQLParser.ADMIN) + pass + + elif la_ == 5: + self.state = 3120 + self.match(PLpgSQLParser.USER) + pass + + + self.state = 3123 + self.identifier_list() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_groupContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def group_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Group_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Group_optionContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_group + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_group" ): + listener.enterCreate_group(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_group" ): + listener.exitCreate_group(self) + + + + + def create_group(self): + + localctx = PLpgSQLParser.Create_groupContext(self, self._ctx, self.state) + self.enterRule(localctx, 238, self.RULE_create_group) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3126 + self.match(PLpgSQLParser.GROUP) + self.state = 3127 + localctx.name = self.identifier() + self.state = 3136 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ADMIN or _la==PLpgSQLParser.ENCRYPTED or _la==PLpgSQLParser.INHERIT or _la==PLpgSQLParser.PASSWORD or _la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.SYSID or _la==PLpgSQLParser.VALID or ((((_la - 405)) & ~0x3f) == 0 and ((1 << (_la - 405)) & ((1 << (PLpgSQLParser.IN - 405)) | (1 << (PLpgSQLParser.USER - 405)) | (1 << (PLpgSQLParser.WITH - 405)) | (1 << (PLpgSQLParser.CREATEDB - 405)) | (1 << (PLpgSQLParser.CREATEROLE - 405)))) != 0) or ((((_la - 485)) & ~0x3f) == 0 and ((1 << (_la - 485)) & ((1 << (PLpgSQLParser.LOGIN - 485)) | (1 << (PLpgSQLParser.NOCREATEDB - 485)) | (1 << (PLpgSQLParser.NOCREATEROLE - 485)) | (1 << (PLpgSQLParser.NOINHERIT - 485)) | (1 << (PLpgSQLParser.NOLOGIN - 485)) | (1 << (PLpgSQLParser.NOSUPERUSER - 485)) | (1 << (PLpgSQLParser.SUPERUSER - 485)))) != 0): + self.state = 3129 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 3128 + self.match(PLpgSQLParser.WITH) + + + self.state = 3132 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3131 + self.group_option() + self.state = 3134 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.ADMIN or _la==PLpgSQLParser.ENCRYPTED or _la==PLpgSQLParser.INHERIT or _la==PLpgSQLParser.PASSWORD or _la==PLpgSQLParser.ROLE or _la==PLpgSQLParser.SYSID or _la==PLpgSQLParser.VALID or ((((_la - 405)) & ~0x3f) == 0 and ((1 << (_la - 405)) & ((1 << (PLpgSQLParser.IN - 405)) | (1 << (PLpgSQLParser.USER - 405)) | (1 << (PLpgSQLParser.CREATEDB - 405)) | (1 << (PLpgSQLParser.CREATEROLE - 405)))) != 0) or ((((_la - 485)) & ~0x3f) == 0 and ((1 << (_la - 485)) & ((1 << (PLpgSQLParser.LOGIN - 485)) | (1 << (PLpgSQLParser.NOCREATEDB - 485)) | (1 << (PLpgSQLParser.NOCREATEROLE - 485)) | (1 << (PLpgSQLParser.NOINHERIT - 485)) | (1 << (PLpgSQLParser.NOLOGIN - 485)) | (1 << (PLpgSQLParser.NOSUPERUSER - 485)) | (1 << (PLpgSQLParser.SUPERUSER - 485)))) != 0)): + break + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Group_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def user_or_role_or_group_common_option(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_or_group_common_optionContext,0) + + + def user_or_role_or_group_option_for_create(self): + return self.getTypedRuleContext(PLpgSQLParser.User_or_role_or_group_option_for_createContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_group_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGroup_option" ): + listener.enterGroup_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGroup_option" ): + listener.exitGroup_option(self) + + + + + def group_option(self): + + localctx = PLpgSQLParser.Group_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 240, self.RULE_group_option) + try: + self.state = 3140 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ENCRYPTED, PLpgSQLParser.INHERIT, PLpgSQLParser.PASSWORD, PLpgSQLParser.VALID, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.LOGIN, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.SUPERUSER]: + self.enterOuterAlt(localctx, 1) + self.state = 3138 + self.user_or_role_or_group_common_option() + pass + elif token in [PLpgSQLParser.ADMIN, PLpgSQLParser.ROLE, PLpgSQLParser.SYSID, PLpgSQLParser.IN, PLpgSQLParser.USER]: + self.enterOuterAlt(localctx, 2) + self.state = 3139 + self.user_or_role_or_group_option_for_create() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_tablespaceContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.directory = None # Token + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def LOCATION(self): + return self.getToken(PLpgSQLParser.LOCATION, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def OWNER(self): + return self.getToken(PLpgSQLParser.OWNER, 0) + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def option_with_value(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Option_with_valueContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Option_with_valueContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_tablespace + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_tablespace" ): + listener.enterCreate_tablespace(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_tablespace" ): + listener.exitCreate_tablespace(self) + + + + + def create_tablespace(self): + + localctx = PLpgSQLParser.Create_tablespaceContext(self, self._ctx, self.state) + self.enterRule(localctx, 242, self.RULE_create_tablespace) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3142 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 3143 + localctx.name = self.identifier() + self.state = 3146 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OWNER: + self.state = 3144 + self.match(PLpgSQLParser.OWNER) + self.state = 3145 + self.user_name() + + + self.state = 3148 + self.match(PLpgSQLParser.LOCATION) + self.state = 3149 + localctx.directory = self.match(PLpgSQLParser.Character_String_Literal) + self.state = 3162 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 3150 + self.match(PLpgSQLParser.WITH) + self.state = 3151 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3152 + self.option_with_value() + self.state = 3157 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3153 + self.match(PLpgSQLParser.COMMA) + self.state = 3154 + self.option_with_value() + self.state = 3159 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3160 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_statisticsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def identifier_list(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Identifier_listContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,i) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_statistics + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_statistics" ): + listener.enterCreate_statistics(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_statistics" ): + listener.exitCreate_statistics(self) + + + + + def create_statistics(self): + + localctx = PLpgSQLParser.Create_statisticsContext(self, self._ctx, self.state) + self.enterRule(localctx, 244, self.RULE_create_statistics) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3164 + self.match(PLpgSQLParser.STATISTICS) + self.state = 3166 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,345,self._ctx) + if la_ == 1: + self.state = 3165 + self.if_not_exists() + + + self.state = 3168 + localctx.name = self.schema_qualified_name() + self.state = 3173 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 3169 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3170 + self.identifier_list() + self.state = 3171 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 3175 + self.match(PLpgSQLParser.ON) + self.state = 3176 + self.identifier() + self.state = 3177 + self.match(PLpgSQLParser.COMMA) + self.state = 3178 + self.identifier_list() + self.state = 3179 + self.match(PLpgSQLParser.FROM) + self.state = 3180 + self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_foreign_data_wrapperContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def HANDLER(self): + return self.getToken(PLpgSQLParser.HANDLER, 0) + + def schema_qualified_name_nontype(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_name_nontypeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_name_nontypeContext,i) + + + def NO(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NO) + else: + return self.getToken(PLpgSQLParser.NO, i) + + def VALIDATOR(self): + return self.getToken(PLpgSQLParser.VALIDATOR, 0) + + def OPTIONS(self): + return self.getToken(PLpgSQLParser.OPTIONS, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def option_without_equal(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Option_without_equalContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Option_without_equalContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_foreign_data_wrapper + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_foreign_data_wrapper" ): + listener.enterCreate_foreign_data_wrapper(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_foreign_data_wrapper" ): + listener.exitCreate_foreign_data_wrapper(self) + + + + + def create_foreign_data_wrapper(self): + + localctx = PLpgSQLParser.Create_foreign_data_wrapperContext(self, self._ctx, self.state) + self.enterRule(localctx, 246, self.RULE_create_foreign_data_wrapper) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3182 + self.match(PLpgSQLParser.FOREIGN) + self.state = 3183 + self.match(PLpgSQLParser.DATA) + self.state = 3184 + self.match(PLpgSQLParser.WRAPPER) + self.state = 3185 + localctx.name = self.identifier() + self.state = 3190 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,347,self._ctx) + if la_ == 1: + self.state = 3186 + self.match(PLpgSQLParser.HANDLER) + self.state = 3187 + self.schema_qualified_name_nontype() + + elif la_ == 2: + self.state = 3188 + self.match(PLpgSQLParser.NO) + self.state = 3189 + self.match(PLpgSQLParser.HANDLER) + + + self.state = 3196 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VALIDATOR]: + self.state = 3192 + self.match(PLpgSQLParser.VALIDATOR) + self.state = 3193 + self.schema_qualified_name_nontype() + pass + elif token in [PLpgSQLParser.NO]: + self.state = 3194 + self.match(PLpgSQLParser.NO) + self.state = 3195 + self.match(PLpgSQLParser.VALIDATOR) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.OPTIONS, PLpgSQLParser.SEMI_COLON]: + pass + else: + pass + self.state = 3210 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 3198 + self.match(PLpgSQLParser.OPTIONS) + self.state = 3199 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3200 + self.option_without_equal() + self.state = 3205 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3201 + self.match(PLpgSQLParser.COMMA) + self.state = 3202 + self.option_without_equal() + self.state = 3207 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3208 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Option_without_equalContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_option_without_equal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption_without_equal" ): + listener.enterOption_without_equal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption_without_equal" ): + listener.exitOption_without_equal(self) + + + + + def option_without_equal(self): + + localctx = PLpgSQLParser.Option_without_equalContext(self, self._ctx, self.state) + self.enterRule(localctx, 248, self.RULE_option_without_equal) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3212 + self.identifier() + self.state = 3213 + self.match(PLpgSQLParser.Character_String_Literal) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_operator_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Operator_nameContext + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def operator_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Operator_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Operator_optionContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def operator_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Operator_nameContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_operator_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_operator_statement" ): + listener.enterCreate_operator_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_operator_statement" ): + listener.exitCreate_operator_statement(self) + + + + + def create_operator_statement(self): + + localctx = PLpgSQLParser.Create_operator_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 250, self.RULE_create_operator_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3215 + self.match(PLpgSQLParser.OPERATOR) + self.state = 3216 + localctx.name = self.operator_name() + self.state = 3217 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3218 + self.operator_option() + self.state = 3223 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3219 + self.match(PLpgSQLParser.COMMA) + self.state = 3220 + self.operator_option() + self.state = 3225 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3226 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Operator_nameContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.schema_name = None # IdentifierContext + self.operator = None # All_simple_opContext + + def all_simple_op(self): + return self.getTypedRuleContext(PLpgSQLParser.All_simple_opContext,0) + + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_operator_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOperator_name" ): + listener.enterOperator_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOperator_name" ): + listener.exitOperator_name(self) + + + + + def operator_name(self): + + localctx = PLpgSQLParser.Operator_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 252, self.RULE_operator_name) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3231 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 3228 + localctx.schema_name = self.identifier() + self.state = 3229 + self.match(PLpgSQLParser.DOT) + + + self.state = 3233 + localctx.operator = self.all_simple_op() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Operator_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.func_name = None # Schema_qualified_nameContext + self.restr_name = None # Schema_qualified_nameContext + self.join_name = None # Schema_qualified_nameContext + self.type = None # Data_typeContext + self.addition_oper_name = None # All_op_refContext + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def RESTRICT(self): + return self.getToken(PLpgSQLParser.RESTRICT, 0) + + def JOIN(self): + return self.getToken(PLpgSQLParser.JOIN, 0) + + def LEFTARG(self): + return self.getToken(PLpgSQLParser.LEFTARG, 0) + + def RIGHTARG(self): + return self.getToken(PLpgSQLParser.RIGHTARG, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def COMMUTATOR(self): + return self.getToken(PLpgSQLParser.COMMUTATOR, 0) + + def NEGATOR(self): + return self.getToken(PLpgSQLParser.NEGATOR, 0) + + def all_op_ref(self): + return self.getTypedRuleContext(PLpgSQLParser.All_op_refContext,0) + + + def HASHES(self): + return self.getToken(PLpgSQLParser.HASHES, 0) + + def MERGES(self): + return self.getToken(PLpgSQLParser.MERGES, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_operator_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOperator_option" ): + listener.enterOperator_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOperator_option" ): + listener.exitOperator_option(self) + + + + + def operator_option(self): + + localctx = PLpgSQLParser.Operator_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 254, self.RULE_operator_option) + self._la = 0 # Token type + try: + self.state = 3252 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.FUNCTION, PLpgSQLParser.PROCEDURE]: + self.enterOuterAlt(localctx, 1) + self.state = 3235 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3236 + self.match(PLpgSQLParser.EQUAL) + self.state = 3237 + localctx.func_name = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.RESTRICT]: + self.enterOuterAlt(localctx, 2) + self.state = 3238 + self.match(PLpgSQLParser.RESTRICT) + self.state = 3239 + self.match(PLpgSQLParser.EQUAL) + self.state = 3240 + localctx.restr_name = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.JOIN]: + self.enterOuterAlt(localctx, 3) + self.state = 3241 + self.match(PLpgSQLParser.JOIN) + self.state = 3242 + self.match(PLpgSQLParser.EQUAL) + self.state = 3243 + localctx.join_name = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.LEFTARG, PLpgSQLParser.RIGHTARG]: + self.enterOuterAlt(localctx, 4) + self.state = 3244 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.LEFTARG or _la==PLpgSQLParser.RIGHTARG): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3245 + self.match(PLpgSQLParser.EQUAL) + self.state = 3246 + localctx.type = self.data_type() + pass + elif token in [PLpgSQLParser.COMMUTATOR, PLpgSQLParser.NEGATOR]: + self.enterOuterAlt(localctx, 5) + self.state = 3247 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.COMMUTATOR or _la==PLpgSQLParser.NEGATOR): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3248 + self.match(PLpgSQLParser.EQUAL) + self.state = 3249 + localctx.addition_oper_name = self.all_op_ref() + pass + elif token in [PLpgSQLParser.HASHES]: + self.enterOuterAlt(localctx, 6) + self.state = 3250 + self.match(PLpgSQLParser.HASHES) + pass + elif token in [PLpgSQLParser.MERGES]: + self.enterOuterAlt(localctx, 7) + self.state = 3251 + self.match(PLpgSQLParser.MERGES) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_aggregate_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.base_type = None # Data_typeContext + self.sfunc_name = None # Schema_qualified_nameContext + self.type = None # Data_typeContext + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def SFUNC(self): + return self.getToken(PLpgSQLParser.SFUNC, 0) + + def EQUAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EQUAL) + else: + return self.getToken(PLpgSQLParser.EQUAL, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def STYPE(self): + return self.getToken(PLpgSQLParser.STYPE, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def BASETYPE(self): + return self.getToken(PLpgSQLParser.BASETYPE, 0) + + def aggregate_param(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Aggregate_paramContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Aggregate_paramContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_aggregate_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_aggregate_statement" ): + listener.enterCreate_aggregate_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_aggregate_statement" ): + listener.exitCreate_aggregate_statement(self) + + + + + def create_aggregate_statement(self): + + localctx = PLpgSQLParser.Create_aggregate_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 256, self.RULE_create_aggregate_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3256 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 3254 + self.match(PLpgSQLParser.OR) + self.state = 3255 + self.match(PLpgSQLParser.REPLACE) + + + self.state = 3258 + self.match(PLpgSQLParser.AGGREGATE) + self.state = 3259 + localctx.name = self.schema_qualified_name() + self.state = 3261 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,355,self._ctx) + if la_ == 1: + self.state = 3260 + self.function_args() + + + self.state = 3263 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3269 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BASETYPE: + self.state = 3264 + self.match(PLpgSQLParser.BASETYPE) + self.state = 3265 + self.match(PLpgSQLParser.EQUAL) + self.state = 3266 + localctx.base_type = self.data_type() + self.state = 3267 + self.match(PLpgSQLParser.COMMA) + + + self.state = 3271 + self.match(PLpgSQLParser.SFUNC) + self.state = 3272 + self.match(PLpgSQLParser.EQUAL) + self.state = 3273 + localctx.sfunc_name = self.schema_qualified_name() + self.state = 3274 + self.match(PLpgSQLParser.COMMA) + self.state = 3275 + self.match(PLpgSQLParser.STYPE) + self.state = 3276 + self.match(PLpgSQLParser.EQUAL) + self.state = 3277 + localctx.type = self.data_type() + self.state = 3282 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3278 + self.match(PLpgSQLParser.COMMA) + self.state = 3279 + self.aggregate_param() + self.state = 3284 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3285 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Aggregate_paramContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.s_space = None # Token + self.final_func = None # Schema_qualified_nameContext + self.combine_func = None # Schema_qualified_nameContext + self.serial_func = None # Schema_qualified_nameContext + self.deserial_func = None # Schema_qualified_nameContext + self.init_cond = None # VexContext + self.ms_func = None # Schema_qualified_nameContext + self.minv_func = None # Schema_qualified_nameContext + self.ms_type = None # Data_typeContext + self.ms_space = None # Token + self.mfinal_func = None # Schema_qualified_nameContext + self.minit_cond = None # VexContext + + def SSPACE(self): + return self.getToken(PLpgSQLParser.SSPACE, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def FINALFUNC(self): + return self.getToken(PLpgSQLParser.FINALFUNC, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def FINALFUNC_EXTRA(self): + return self.getToken(PLpgSQLParser.FINALFUNC_EXTRA, 0) + + def FINALFUNC_MODIFY(self): + return self.getToken(PLpgSQLParser.FINALFUNC_MODIFY, 0) + + def READ_ONLY(self): + return self.getToken(PLpgSQLParser.READ_ONLY, 0) + + def SHAREABLE(self): + return self.getToken(PLpgSQLParser.SHAREABLE, 0) + + def READ_WRITE(self): + return self.getToken(PLpgSQLParser.READ_WRITE, 0) + + def COMBINEFUNC(self): + return self.getToken(PLpgSQLParser.COMBINEFUNC, 0) + + def SERIALFUNC(self): + return self.getToken(PLpgSQLParser.SERIALFUNC, 0) + + def DESERIALFUNC(self): + return self.getToken(PLpgSQLParser.DESERIALFUNC, 0) + + def INITCOND(self): + return self.getToken(PLpgSQLParser.INITCOND, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def MSFUNC(self): + return self.getToken(PLpgSQLParser.MSFUNC, 0) + + def MINVFUNC(self): + return self.getToken(PLpgSQLParser.MINVFUNC, 0) + + def MSTYPE(self): + return self.getToken(PLpgSQLParser.MSTYPE, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def MSSPACE(self): + return self.getToken(PLpgSQLParser.MSSPACE, 0) + + def MFINALFUNC(self): + return self.getToken(PLpgSQLParser.MFINALFUNC, 0) + + def MFINALFUNC_EXTRA(self): + return self.getToken(PLpgSQLParser.MFINALFUNC_EXTRA, 0) + + def MFINALFUNC_MODIFY(self): + return self.getToken(PLpgSQLParser.MFINALFUNC_MODIFY, 0) + + def MINITCOND(self): + return self.getToken(PLpgSQLParser.MINITCOND, 0) + + def SORTOP(self): + return self.getToken(PLpgSQLParser.SORTOP, 0) + + def all_op_ref(self): + return self.getTypedRuleContext(PLpgSQLParser.All_op_refContext,0) + + + def PARALLEL(self): + return self.getToken(PLpgSQLParser.PARALLEL, 0) + + def SAFE(self): + return self.getToken(PLpgSQLParser.SAFE, 0) + + def RESTRICTED(self): + return self.getToken(PLpgSQLParser.RESTRICTED, 0) + + def UNSAFE(self): + return self.getToken(PLpgSQLParser.UNSAFE, 0) + + def HYPOTHETICAL(self): + return self.getToken(PLpgSQLParser.HYPOTHETICAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_aggregate_param + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAggregate_param" ): + listener.enterAggregate_param(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAggregate_param" ): + listener.exitAggregate_param(self) + + + + + def aggregate_param(self): + + localctx = PLpgSQLParser.Aggregate_paramContext(self, self._ctx, self.state) + self.enterRule(localctx, 258, self.RULE_aggregate_param) + self._la = 0 # Token type + try: + self.state = 3338 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SSPACE]: + self.enterOuterAlt(localctx, 1) + self.state = 3287 + self.match(PLpgSQLParser.SSPACE) + self.state = 3288 + self.match(PLpgSQLParser.EQUAL) + self.state = 3289 + localctx.s_space = self.match(PLpgSQLParser.NUMBER_LITERAL) + pass + elif token in [PLpgSQLParser.FINALFUNC]: + self.enterOuterAlt(localctx, 2) + self.state = 3290 + self.match(PLpgSQLParser.FINALFUNC) + self.state = 3291 + self.match(PLpgSQLParser.EQUAL) + self.state = 3292 + localctx.final_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.FINALFUNC_EXTRA]: + self.enterOuterAlt(localctx, 3) + self.state = 3293 + self.match(PLpgSQLParser.FINALFUNC_EXTRA) + pass + elif token in [PLpgSQLParser.FINALFUNC_MODIFY]: + self.enterOuterAlt(localctx, 4) + self.state = 3294 + self.match(PLpgSQLParser.FINALFUNC_MODIFY) + self.state = 3295 + self.match(PLpgSQLParser.EQUAL) + self.state = 3296 + _la = self._input.LA(1) + if not(((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.COMBINEFUNC]: + self.enterOuterAlt(localctx, 5) + self.state = 3297 + self.match(PLpgSQLParser.COMBINEFUNC) + self.state = 3298 + self.match(PLpgSQLParser.EQUAL) + self.state = 3299 + localctx.combine_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.SERIALFUNC]: + self.enterOuterAlt(localctx, 6) + self.state = 3300 + self.match(PLpgSQLParser.SERIALFUNC) + self.state = 3301 + self.match(PLpgSQLParser.EQUAL) + self.state = 3302 + localctx.serial_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.DESERIALFUNC]: + self.enterOuterAlt(localctx, 7) + self.state = 3303 + self.match(PLpgSQLParser.DESERIALFUNC) + self.state = 3304 + self.match(PLpgSQLParser.EQUAL) + self.state = 3305 + localctx.deserial_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.INITCOND]: + self.enterOuterAlt(localctx, 8) + self.state = 3306 + self.match(PLpgSQLParser.INITCOND) + self.state = 3307 + self.match(PLpgSQLParser.EQUAL) + self.state = 3308 + localctx.init_cond = self.vex(0) + pass + elif token in [PLpgSQLParser.MSFUNC]: + self.enterOuterAlt(localctx, 9) + self.state = 3309 + self.match(PLpgSQLParser.MSFUNC) + self.state = 3310 + self.match(PLpgSQLParser.EQUAL) + self.state = 3311 + localctx.ms_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.MINVFUNC]: + self.enterOuterAlt(localctx, 10) + self.state = 3312 + self.match(PLpgSQLParser.MINVFUNC) + self.state = 3313 + self.match(PLpgSQLParser.EQUAL) + self.state = 3314 + localctx.minv_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.MSTYPE]: + self.enterOuterAlt(localctx, 11) + self.state = 3315 + self.match(PLpgSQLParser.MSTYPE) + self.state = 3316 + self.match(PLpgSQLParser.EQUAL) + self.state = 3317 + localctx.ms_type = self.data_type() + pass + elif token in [PLpgSQLParser.MSSPACE]: + self.enterOuterAlt(localctx, 12) + self.state = 3318 + self.match(PLpgSQLParser.MSSPACE) + self.state = 3319 + self.match(PLpgSQLParser.EQUAL) + self.state = 3320 + localctx.ms_space = self.match(PLpgSQLParser.NUMBER_LITERAL) + pass + elif token in [PLpgSQLParser.MFINALFUNC]: + self.enterOuterAlt(localctx, 13) + self.state = 3321 + self.match(PLpgSQLParser.MFINALFUNC) + self.state = 3322 + self.match(PLpgSQLParser.EQUAL) + self.state = 3323 + localctx.mfinal_func = self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.MFINALFUNC_EXTRA]: + self.enterOuterAlt(localctx, 14) + self.state = 3324 + self.match(PLpgSQLParser.MFINALFUNC_EXTRA) + pass + elif token in [PLpgSQLParser.MFINALFUNC_MODIFY]: + self.enterOuterAlt(localctx, 15) + self.state = 3325 + self.match(PLpgSQLParser.MFINALFUNC_MODIFY) + self.state = 3326 + self.match(PLpgSQLParser.EQUAL) + self.state = 3327 + _la = self._input.LA(1) + if not(((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.MINITCOND]: + self.enterOuterAlt(localctx, 16) + self.state = 3328 + self.match(PLpgSQLParser.MINITCOND) + self.state = 3329 + self.match(PLpgSQLParser.EQUAL) + self.state = 3330 + localctx.minit_cond = self.vex(0) + pass + elif token in [PLpgSQLParser.SORTOP]: + self.enterOuterAlt(localctx, 17) + self.state = 3331 + self.match(PLpgSQLParser.SORTOP) + self.state = 3332 + self.match(PLpgSQLParser.EQUAL) + self.state = 3333 + self.all_op_ref() + pass + elif token in [PLpgSQLParser.PARALLEL]: + self.enterOuterAlt(localctx, 18) + self.state = 3334 + self.match(PLpgSQLParser.PARALLEL) + self.state = 3335 + self.match(PLpgSQLParser.EQUAL) + self.state = 3336 + _la = self._input.LA(1) + if not(((((_la - 517)) & ~0x3f) == 0 and ((1 << (_la - 517)) & ((1 << (PLpgSQLParser.RESTRICTED - 517)) | (1 << (PLpgSQLParser.SAFE - 517)) | (1 << (PLpgSQLParser.UNSAFE - 517)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.HYPOTHETICAL]: + self.enterOuterAlt(localctx, 19) + self.state = 3337 + self.match(PLpgSQLParser.HYPOTHETICAL) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Set_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def set_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_set_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet_statement" ): + listener.enterSet_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet_statement" ): + listener.exitSet_statement(self) + + + + + def set_statement(self): + + localctx = PLpgSQLParser.Set_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 260, self.RULE_set_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3340 + self.match(PLpgSQLParser.SET) + self.state = 3341 + self.set_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Set_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONSTRAINTS(self): + return self.getToken(PLpgSQLParser.CONSTRAINTS, 0) + + def DEFERRED(self): + return self.getToken(PLpgSQLParser.DEFERRED, 0) + + def IMMEDIATE(self): + return self.getToken(PLpgSQLParser.IMMEDIATE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def names_references(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_referencesContext,0) + + + def TRANSACTION(self): + return self.getToken(PLpgSQLParser.TRANSACTION, 0) + + def transaction_mode(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Transaction_modeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Transaction_modeContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def SNAPSHOT(self): + return self.getToken(PLpgSQLParser.SNAPSHOT, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def SESSION(self): + return self.getToken(PLpgSQLParser.SESSION, 0) + + def CHARACTERISTICS(self): + return self.getToken(PLpgSQLParser.CHARACTERISTICS, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def session_local_option(self): + return self.getTypedRuleContext(PLpgSQLParser.Session_local_optionContext,0) + + + def LOCAL(self): + return self.getToken(PLpgSQLParser.LOCAL, 0) + + def XML(self): + return self.getToken(PLpgSQLParser.XML, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def DOCUMENT(self): + return self.getToken(PLpgSQLParser.DOCUMENT, 0) + + def CONTENT(self): + return self.getToken(PLpgSQLParser.CONTENT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_set_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet_action" ): + listener.enterSet_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet_action" ): + listener.exitSet_action(self) + + + + + def set_action(self): + + localctx = PLpgSQLParser.Set_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 262, self.RULE_set_action) + self._la = 0 # Token type + try: + self.state = 3380 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,363,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3343 + self.match(PLpgSQLParser.CONSTRAINTS) + self.state = 3346 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALL]: + self.state = 3344 + self.match(PLpgSQLParser.ALL) + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 3345 + self.names_references() + pass + else: + raise NoViableAltException(self) + + self.state = 3348 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DEFERRED or _la==PLpgSQLParser.IMMEDIATE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3349 + self.match(PLpgSQLParser.TRANSACTION) + self.state = 3350 + self.transaction_mode() + self.state = 3355 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3351 + self.match(PLpgSQLParser.COMMA) + self.state = 3352 + self.transaction_mode() + self.state = 3357 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3358 + self.match(PLpgSQLParser.TRANSACTION) + self.state = 3359 + self.match(PLpgSQLParser.SNAPSHOT) + self.state = 3360 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3361 + self.match(PLpgSQLParser.SESSION) + self.state = 3362 + self.match(PLpgSQLParser.CHARACTERISTICS) + self.state = 3363 + self.match(PLpgSQLParser.AS) + self.state = 3364 + self.match(PLpgSQLParser.TRANSACTION) + self.state = 3365 + self.transaction_mode() + self.state = 3370 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3366 + self.match(PLpgSQLParser.COMMA) + self.state = 3367 + self.transaction_mode() + self.state = 3372 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3374 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,362,self._ctx) + if la_ == 1: + self.state = 3373 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.LOCAL or _la==PLpgSQLParser.SESSION): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 3376 + self.session_local_option() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3377 + self.match(PLpgSQLParser.XML) + self.state = 3378 + self.match(PLpgSQLParser.OPTION) + self.state = 3379 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONTENT or _la==PLpgSQLParser.DOCUMENT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Session_local_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.config_param = None # IdentifierContext + + def SESSION(self): + return self.getToken(PLpgSQLParser.SESSION, 0) + + def AUTHORIZATION(self): + return self.getToken(PLpgSQLParser.AUTHORIZATION, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def TIME(self): + return self.getToken(PLpgSQLParser.TIME, 0) + + def ZONE(self): + return self.getToken(PLpgSQLParser.ZONE, 0) + + def signed_numerical_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Signed_numerical_literalContext,0) + + + def LOCAL(self): + return self.getToken(PLpgSQLParser.LOCAL, 0) + + def set_statement_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_statement_valueContext,0) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def NONE(self): + return self.getToken(PLpgSQLParser.NONE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_session_local_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSession_local_option" ): + listener.enterSession_local_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSession_local_option" ): + listener.exitSession_local_option(self) + + + + + def session_local_option(self): + + localctx = PLpgSQLParser.Session_local_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 264, self.RULE_session_local_option) + self._la = 0 # Token type + try: + self.state = 3411 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,368,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3382 + self.match(PLpgSQLParser.SESSION) + self.state = 3383 + self.match(PLpgSQLParser.AUTHORIZATION) + self.state = 3387 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Character_String_Literal]: + self.state = 3384 + self.match(PLpgSQLParser.Character_String_Literal) + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 3385 + self.identifier() + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 3386 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3389 + self.match(PLpgSQLParser.TIME) + self.state = 3390 + self.match(PLpgSQLParser.ZONE) + self.state = 3395 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Character_String_Literal]: + self.state = 3391 + self.match(PLpgSQLParser.Character_String_Literal) + pass + elif token in [PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER]: + self.state = 3392 + self.signed_numerical_literal() + pass + elif token in [PLpgSQLParser.LOCAL]: + self.state = 3393 + self.match(PLpgSQLParser.LOCAL) + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 3394 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3400 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,366,self._ctx) + if la_ == 1: + self.state = 3397 + self.identifier() + self.state = 3398 + self.match(PLpgSQLParser.DOT) + + + self.state = 3402 + localctx.config_param = self.identifier() + self.state = 3403 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TO or _la==PLpgSQLParser.EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3404 + self.set_statement_value() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3406 + self.match(PLpgSQLParser.ROLE) + self.state = 3409 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,367,self._ctx) + if la_ == 1: + self.state = 3407 + self.identifier() + pass + + elif la_ == 2: + self.state = 3408 + self.match(PLpgSQLParser.NONE) + pass + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Set_statement_valueContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_set_statement_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet_statement_value" ): + listener.enterSet_statement_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet_statement_value" ): + listener.exitSet_statement_value(self) + + + + + def set_statement_value(self): + + localctx = PLpgSQLParser.Set_statement_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 266, self.RULE_set_statement_value) + self._la = 0 # Token type + try: + self.state = 3422 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.enterOuterAlt(localctx, 1) + self.state = 3413 + self.vex(0) + self.state = 3418 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3414 + self.match(PLpgSQLParser.COMMA) + self.state = 3415 + self.vex(0) + self.state = 3420 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.enterOuterAlt(localctx, 2) + self.state = 3421 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_rewrite_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.event = None # Token + self.table_name = None # Schema_qualified_nameContext + + def RULE(self): + return self.getToken(PLpgSQLParser.RULE, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def DO(self): + return self.getToken(PLpgSQLParser.DO, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def INSERT(self): + return self.getToken(PLpgSQLParser.INSERT, 0) + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def NOTHING(self): + return self.getToken(PLpgSQLParser.NOTHING, 0) + + def rewrite_command(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Rewrite_commandContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Rewrite_commandContext,i) + + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def ALSO(self): + return self.getToken(PLpgSQLParser.ALSO, 0) + + def INSTEAD(self): + return self.getToken(PLpgSQLParser.INSTEAD, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def SEMI_COLON(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SEMI_COLON) + else: + return self.getToken(PLpgSQLParser.SEMI_COLON, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_rewrite_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_rewrite_statement" ): + listener.enterCreate_rewrite_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_rewrite_statement" ): + listener.exitCreate_rewrite_statement(self) + + + + + def create_rewrite_statement(self): + + localctx = PLpgSQLParser.Create_rewrite_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 268, self.RULE_create_rewrite_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3426 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 3424 + self.match(PLpgSQLParser.OR) + self.state = 3425 + self.match(PLpgSQLParser.REPLACE) + + + self.state = 3428 + self.match(PLpgSQLParser.RULE) + self.state = 3429 + localctx.name = self.identifier() + self.state = 3430 + self.match(PLpgSQLParser.AS) + self.state = 3431 + self.match(PLpgSQLParser.ON) + self.state = 3432 + localctx.event = self._input.LT(1) + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DELETE or _la==PLpgSQLParser.INSERT or _la==PLpgSQLParser.UPDATE or _la==PLpgSQLParser.SELECT): + localctx.event = self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3433 + self.match(PLpgSQLParser.TO) + self.state = 3434 + localctx.table_name = self.schema_qualified_name() + self.state = 3437 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 3435 + self.match(PLpgSQLParser.WHERE) + self.state = 3436 + self.vex(0) + + + self.state = 3439 + self.match(PLpgSQLParser.DO) + self.state = 3441 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALSO or _la==PLpgSQLParser.INSTEAD: + self.state = 3440 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALSO or _la==PLpgSQLParser.INSTEAD): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 3460 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,376,self._ctx) + if la_ == 1: + self.state = 3443 + self.match(PLpgSQLParser.NOTHING) + pass + + elif la_ == 2: + self.state = 3444 + self.rewrite_command() + pass + + elif la_ == 3: + self.state = 3445 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3451 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,374,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 3446 + self.rewrite_command() + self.state = 3447 + self.match(PLpgSQLParser.SEMI_COLON) + self.state = 3453 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,374,self._ctx) + + self.state = 3454 + self.rewrite_command() + self.state = 3456 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.SEMI_COLON: + self.state = 3455 + self.match(PLpgSQLParser.SEMI_COLON) + + + self.state = 3458 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Rewrite_commandContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def insert_stmt_for_psql(self): + return self.getTypedRuleContext(PLpgSQLParser.Insert_stmt_for_psqlContext,0) + + + def update_stmt_for_psql(self): + return self.getTypedRuleContext(PLpgSQLParser.Update_stmt_for_psqlContext,0) + + + def delete_stmt_for_psql(self): + return self.getTypedRuleContext(PLpgSQLParser.Delete_stmt_for_psqlContext,0) + + + def notify_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Notify_stmtContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_rewrite_command + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRewrite_command" ): + listener.enterRewrite_command(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRewrite_command" ): + listener.exitRewrite_command(self) + + + + + def rewrite_command(self): + + localctx = PLpgSQLParser.Rewrite_commandContext(self, self._ctx, self.state) + self.enterRule(localctx, 270, self.RULE_rewrite_command) + try: + self.state = 3467 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,377,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3462 + self.select_stmt() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3463 + self.insert_stmt_for_psql() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3464 + self.update_stmt_for_psql() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3465 + self.delete_stmt_for_psql() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3466 + self.notify_stmt() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_trigger_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.before_true = None # Token + self.insert_true = None # Token + self.delete_true = None # Token + self.truncate_true = None # Token + self.update_true = None # Token + self.table_name = None # Schema_qualified_nameContext + self.referenced_table_name = None # Schema_qualified_nameContext + self.for_each_true = None # Token + self.func_name = None # Function_callContext + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def AFTER(self): + return self.getToken(PLpgSQLParser.AFTER, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def BEFORE(self): + return self.getToken(PLpgSQLParser.BEFORE, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def table_deferrable(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_deferrableContext,0) + + + def table_initialy_immed(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_initialy_immedContext,0) + + + def REFERENCING(self): + return self.getToken(PLpgSQLParser.REFERENCING, 0) + + def trigger_referencing(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Trigger_referencingContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Trigger_referencingContext,i) + + + def when_trigger(self): + return self.getTypedRuleContext(PLpgSQLParser.When_triggerContext,0) + + + def INSTEAD(self): + return self.getToken(PLpgSQLParser.INSTEAD, 0) + + def OF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.OF) + else: + return self.getToken(PLpgSQLParser.OF, i) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def STATEMENT(self): + return self.getToken(PLpgSQLParser.STATEMENT, 0) + + def UPDATE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.UPDATE) + else: + return self.getToken(PLpgSQLParser.UPDATE, i) + + def OR(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.OR) + else: + return self.getToken(PLpgSQLParser.OR, i) + + def EACH(self): + return self.getToken(PLpgSQLParser.EACH, 0) + + def INSERT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.INSERT) + else: + return self.getToken(PLpgSQLParser.INSERT, i) + + def DELETE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DELETE) + else: + return self.getToken(PLpgSQLParser.DELETE, i) + + def TRUNCATE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.TRUNCATE) + else: + return self.getToken(PLpgSQLParser.TRUNCATE, i) + + def identifier_list(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Identifier_listContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_trigger_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_trigger_statement" ): + listener.enterCreate_trigger_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_trigger_statement" ): + listener.exitCreate_trigger_statement(self) + + + + + def create_trigger_statement(self): + + localctx = PLpgSQLParser.Create_trigger_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 272, self.RULE_create_trigger_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3470 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONSTRAINT: + self.state = 3469 + self.match(PLpgSQLParser.CONSTRAINT) + + + self.state = 3472 + self.match(PLpgSQLParser.TRIGGER) + self.state = 3473 + localctx.name = self.identifier() + self.state = 3478 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.BEFORE]: + self.state = 3474 + localctx.before_true = self.match(PLpgSQLParser.BEFORE) + pass + elif token in [PLpgSQLParser.INSTEAD]: + self.state = 3475 + self.match(PLpgSQLParser.INSTEAD) + self.state = 3476 + self.match(PLpgSQLParser.OF) + pass + elif token in [PLpgSQLParser.AFTER]: + self.state = 3477 + self.match(PLpgSQLParser.AFTER) + pass + else: + raise NoViableAltException(self) + + self.state = 3495 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3490 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DELETE, PLpgSQLParser.INSERT, PLpgSQLParser.TRUNCATE]: + self.state = 3483 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.INSERT]: + self.state = 3480 + localctx.insert_true = self.match(PLpgSQLParser.INSERT) + pass + elif token in [PLpgSQLParser.DELETE]: + self.state = 3481 + localctx.delete_true = self.match(PLpgSQLParser.DELETE) + pass + elif token in [PLpgSQLParser.TRUNCATE]: + self.state = 3482 + localctx.truncate_true = self.match(PLpgSQLParser.TRUNCATE) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.UPDATE]: + self.state = 3485 + localctx.update_true = self.match(PLpgSQLParser.UPDATE) + self.state = 3488 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OF: + self.state = 3486 + self.match(PLpgSQLParser.OF) + self.state = 3487 + self.identifier_list() + + + pass + else: + raise NoViableAltException(self) + + self.state = 3493 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 3492 + self.match(PLpgSQLParser.OR) + + + self.state = 3497 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.DELETE or _la==PLpgSQLParser.INSERT or _la==PLpgSQLParser.TRUNCATE or _la==PLpgSQLParser.UPDATE): + break + + self.state = 3499 + self.match(PLpgSQLParser.ON) + self.state = 3500 + localctx.table_name = self.schema_qualified_name() + self.state = 3503 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM: + self.state = 3501 + self.match(PLpgSQLParser.FROM) + self.state = 3502 + localctx.referenced_table_name = self.schema_qualified_name() + + + self.state = 3506 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFERRABLE or _la==PLpgSQLParser.NOT: + self.state = 3505 + self.table_deferrable() + + + self.state = 3509 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INITIALLY: + self.state = 3508 + self.table_initialy_immed() + + + self.state = 3516 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.REFERENCING: + self.state = 3511 + self.match(PLpgSQLParser.REFERENCING) + self.state = 3512 + self.trigger_referencing() + self.state = 3514 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NEW or _la==PLpgSQLParser.OLD: + self.state = 3513 + self.trigger_referencing() + + + + + self.state = 3523 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 3518 + localctx.for_each_true = self.match(PLpgSQLParser.FOR) + self.state = 3520 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.EACH: + self.state = 3519 + self.match(PLpgSQLParser.EACH) + + + self.state = 3522 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.STATEMENT or _la==PLpgSQLParser.ROW): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 3526 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHEN: + self.state = 3525 + self.when_trigger() + + + self.state = 3528 + self.match(PLpgSQLParser.EXECUTE) + self.state = 3529 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3530 + localctx.func_name = self.function_call() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Trigger_referencingContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def OLD(self): + return self.getToken(PLpgSQLParser.OLD, 0) + + def NEW(self): + return self.getToken(PLpgSQLParser.NEW, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_trigger_referencing + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTrigger_referencing" ): + listener.enterTrigger_referencing(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTrigger_referencing" ): + listener.exitTrigger_referencing(self) + + + + + def trigger_referencing(self): + + localctx = PLpgSQLParser.Trigger_referencingContext(self, self._ctx, self.state) + self.enterRule(localctx, 274, self.RULE_trigger_referencing) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3532 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.NEW or _la==PLpgSQLParser.OLD): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3533 + self.match(PLpgSQLParser.TABLE) + self.state = 3535 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 3534 + self.match(PLpgSQLParser.AS) + + + self.state = 3537 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class When_triggerContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WHEN(self): + return self.getToken(PLpgSQLParser.WHEN, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_when_trigger + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWhen_trigger" ): + listener.enterWhen_trigger(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWhen_trigger" ): + listener.exitWhen_trigger(self) + + + + + def when_trigger(self): + + localctx = PLpgSQLParser.When_triggerContext(self, self._ctx, self.state) + self.enterRule(localctx, 276, self.RULE_when_trigger) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3539 + self.match(PLpgSQLParser.WHEN) + self.state = 3540 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3541 + self.vex(0) + self.state = 3542 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Rule_commonContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def rule_member_object(self): + return self.getTypedRuleContext(PLpgSQLParser.Rule_member_objectContext,0) + + + def roles_names(self): + return self.getTypedRuleContext(PLpgSQLParser.Roles_namesContext,0) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def GRANT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.GRANT) + else: + return self.getToken(PLpgSQLParser.GRANT, i) + + def REVOKE(self): + return self.getToken(PLpgSQLParser.REVOKE, 0) + + def permissions(self): + return self.getTypedRuleContext(PLpgSQLParser.PermissionsContext,0) + + + def columns_permissions(self): + return self.getTypedRuleContext(PLpgSQLParser.Columns_permissionsContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def grant_option_for(self): + return self.getTypedRuleContext(PLpgSQLParser.Grant_option_forContext,0) + + + def other_rules(self): + return self.getTypedRuleContext(PLpgSQLParser.Other_rulesContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_rule_common + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRule_common" ): + listener.enterRule_common(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRule_common" ): + listener.exitRule_common(self) + + + + + def rule_common(self): + + localctx = PLpgSQLParser.Rule_commonContext(self, self._ctx, self.state) + self.enterRule(localctx, 278, self.RULE_rule_common) + self._la = 0 # Token type + try: + self.state = 3566 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,398,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3549 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.GRANT]: + self.state = 3544 + self.match(PLpgSQLParser.GRANT) + pass + elif token in [PLpgSQLParser.REVOKE]: + self.state = 3545 + self.match(PLpgSQLParser.REVOKE) + self.state = 3547 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GRANT: + self.state = 3546 + self.grant_option_for() + + + pass + else: + raise NoViableAltException(self) + + self.state = 3553 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,396,self._ctx) + if la_ == 1: + self.state = 3551 + self.permissions() + pass + + elif la_ == 2: + self.state = 3552 + self.columns_permissions() + pass + + + self.state = 3555 + self.match(PLpgSQLParser.ON) + self.state = 3556 + self.rule_member_object() + self.state = 3557 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FROM or _la==PLpgSQLParser.TO): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3558 + self.roles_names() + self.state = 3563 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.WITH]: + self.state = 3559 + self.match(PLpgSQLParser.WITH) + self.state = 3560 + self.match(PLpgSQLParser.GRANT) + self.state = 3561 + self.match(PLpgSQLParser.OPTION) + pass + elif token in [PLpgSQLParser.CASCADE, PLpgSQLParser.RESTRICT]: + self.state = 3562 + self.cascade_restrict() + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.SEMI_COLON]: + pass + else: + pass + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3565 + self.other_rules() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Rule_member_objectContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.table_names = None # Names_referencesContext + self._function_parameters = None # Function_parametersContext + self.func_name = list() # of Function_parametersContexts + self.schema_names = None # Names_referencesContext + + def names_references(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_referencesContext,0) + + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def ROUTINE(self): + return self.getToken(PLpgSQLParser.ROUTINE, 0) + + def function_parameters(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_parametersContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_parametersContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def LARGE(self): + return self.getToken(PLpgSQLParser.LARGE, 0) + + def OBJECT(self): + return self.getToken(PLpgSQLParser.OBJECT, 0) + + def NUMBER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NUMBER_LITERAL) + else: + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, i) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def TABLES(self): + return self.getToken(PLpgSQLParser.TABLES, 0) + + def SEQUENCES(self): + return self.getToken(PLpgSQLParser.SEQUENCES, 0) + + def FUNCTIONS(self): + return self.getToken(PLpgSQLParser.FUNCTIONS, 0) + + def PROCEDURES(self): + return self.getToken(PLpgSQLParser.PROCEDURES, 0) + + def ROUTINES(self): + return self.getToken(PLpgSQLParser.ROUTINES, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_rule_member_object + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRule_member_object" ): + listener.enterRule_member_object(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRule_member_object" ): + listener.exitRule_member_object(self) + + + + + def rule_member_object(self): + + localctx = PLpgSQLParser.Rule_member_objectContext(self, self._ctx, self.state) + self.enterRule(localctx, 280, self.RULE_rule_member_object) + self._la = 0 # Token type + try: + self.state = 3617 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,402,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3569 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLE: + self.state = 3568 + self.match(PLpgSQLParser.TABLE) + + + self.state = 3571 + localctx.table_names = self.names_references() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3572 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 3573 + self.names_references() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3574 + self.match(PLpgSQLParser.DATABASE) + self.state = 3575 + self.names_references() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3576 + self.match(PLpgSQLParser.DOMAIN) + self.state = 3577 + self.names_references() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3578 + self.match(PLpgSQLParser.FOREIGN) + self.state = 3579 + self.match(PLpgSQLParser.DATA) + self.state = 3580 + self.match(PLpgSQLParser.WRAPPER) + self.state = 3581 + self.names_references() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3582 + self.match(PLpgSQLParser.FOREIGN) + self.state = 3583 + self.match(PLpgSQLParser.SERVER) + self.state = 3584 + self.names_references() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 3585 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE or _la==PLpgSQLParser.ROUTINE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3586 + localctx._function_parameters = self.function_parameters() + localctx.func_name.append(localctx._function_parameters) + self.state = 3591 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3587 + self.match(PLpgSQLParser.COMMA) + self.state = 3588 + localctx._function_parameters = self.function_parameters() + localctx.func_name.append(localctx._function_parameters) + self.state = 3593 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 3594 + self.match(PLpgSQLParser.LARGE) + self.state = 3595 + self.match(PLpgSQLParser.OBJECT) + self.state = 3596 + self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 3601 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3597 + self.match(PLpgSQLParser.COMMA) + self.state = 3598 + self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 3603 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 3604 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 3605 + self.names_references() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 3606 + self.match(PLpgSQLParser.SCHEMA) + self.state = 3607 + localctx.schema_names = self.names_references() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 3608 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 3609 + self.names_references() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 3610 + self.match(PLpgSQLParser.TYPE) + self.state = 3611 + self.names_references() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 3612 + self.match(PLpgSQLParser.ALL) + self.state = 3613 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTIONS or ((((_la - 185)) & ~0x3f) == 0 and ((1 << (_la - 185)) & ((1 << (PLpgSQLParser.PROCEDURES - 185)) | (1 << (PLpgSQLParser.ROUTINES - 185)) | (1 << (PLpgSQLParser.SEQUENCES - 185)))) != 0) or _la==PLpgSQLParser.TABLES): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3614 + self.match(PLpgSQLParser.IN) + self.state = 3615 + self.match(PLpgSQLParser.SCHEMA) + self.state = 3616 + self.names_references() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Columns_permissionsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def table_column_privileges(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_column_privilegesContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_column_privilegesContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_columns_permissions + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterColumns_permissions" ): + listener.enterColumns_permissions(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitColumns_permissions" ): + listener.exitColumns_permissions(self) + + + + + def columns_permissions(self): + + localctx = PLpgSQLParser.Columns_permissionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 282, self.RULE_columns_permissions) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3619 + self.table_column_privileges() + self.state = 3624 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3620 + self.match(PLpgSQLParser.COMMA) + self.state = 3621 + self.table_column_privileges() + self.state = 3626 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_column_privilegesContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def table_column_privilege(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_column_privilegeContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_column_privileges + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_column_privileges" ): + listener.enterTable_column_privileges(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_column_privileges" ): + listener.exitTable_column_privileges(self) + + + + + def table_column_privileges(self): + + localctx = PLpgSQLParser.Table_column_privilegesContext(self, self._ctx, self.state) + self.enterRule(localctx, 284, self.RULE_table_column_privileges) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3627 + self.table_column_privilege() + self.state = 3628 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3629 + self.identifier_list() + self.state = 3630 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PermissionsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def permission(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.PermissionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.PermissionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_permissions + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPermissions" ): + listener.enterPermissions(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPermissions" ): + listener.exitPermissions(self) + + + + + def permissions(self): + + localctx = PLpgSQLParser.PermissionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 286, self.RULE_permissions) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3632 + self.permission() + self.state = 3637 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3633 + self.match(PLpgSQLParser.COMMA) + self.state = 3634 + self.permission() + self.state = 3639 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PermissionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def PRIVILEGES(self): + return self.getToken(PLpgSQLParser.PRIVILEGES, 0) + + def CONNECT(self): + return self.getToken(PLpgSQLParser.CONNECT, 0) + + def CREATE(self): + return self.getToken(PLpgSQLParser.CREATE, 0) + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def INSERT(self): + return self.getToken(PLpgSQLParser.INSERT, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def REFERENCES(self): + return self.getToken(PLpgSQLParser.REFERENCES, 0) + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def TRUNCATE(self): + return self.getToken(PLpgSQLParser.TRUNCATE, 0) + + def USAGE(self): + return self.getToken(PLpgSQLParser.USAGE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_permission + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPermission" ): + listener.enterPermission(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPermission" ): + listener.exitPermission(self) + + + + + def permission(self): + + localctx = PLpgSQLParser.PermissionContext(self, self._ctx, self.state) + self.enterRule(localctx, 288, self.RULE_permission) + self._la = 0 # Token type + try: + self.state = 3656 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALL]: + self.enterOuterAlt(localctx, 1) + self.state = 3640 + self.match(PLpgSQLParser.ALL) + self.state = 3642 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PRIVILEGES: + self.state = 3641 + self.match(PLpgSQLParser.PRIVILEGES) + + + pass + elif token in [PLpgSQLParser.CONNECT]: + self.enterOuterAlt(localctx, 2) + self.state = 3644 + self.match(PLpgSQLParser.CONNECT) + pass + elif token in [PLpgSQLParser.CREATE]: + self.enterOuterAlt(localctx, 3) + self.state = 3645 + self.match(PLpgSQLParser.CREATE) + pass + elif token in [PLpgSQLParser.DELETE]: + self.enterOuterAlt(localctx, 4) + self.state = 3646 + self.match(PLpgSQLParser.DELETE) + pass + elif token in [PLpgSQLParser.EXECUTE]: + self.enterOuterAlt(localctx, 5) + self.state = 3647 + self.match(PLpgSQLParser.EXECUTE) + pass + elif token in [PLpgSQLParser.INSERT]: + self.enterOuterAlt(localctx, 6) + self.state = 3648 + self.match(PLpgSQLParser.INSERT) + pass + elif token in [PLpgSQLParser.UPDATE]: + self.enterOuterAlt(localctx, 7) + self.state = 3649 + self.match(PLpgSQLParser.UPDATE) + pass + elif token in [PLpgSQLParser.REFERENCES]: + self.enterOuterAlt(localctx, 8) + self.state = 3650 + self.match(PLpgSQLParser.REFERENCES) + pass + elif token in [PLpgSQLParser.SELECT]: + self.enterOuterAlt(localctx, 9) + self.state = 3651 + self.match(PLpgSQLParser.SELECT) + pass + elif token in [PLpgSQLParser.TEMP]: + self.enterOuterAlt(localctx, 10) + self.state = 3652 + self.match(PLpgSQLParser.TEMP) + pass + elif token in [PLpgSQLParser.TRIGGER]: + self.enterOuterAlt(localctx, 11) + self.state = 3653 + self.match(PLpgSQLParser.TRIGGER) + pass + elif token in [PLpgSQLParser.TRUNCATE]: + self.enterOuterAlt(localctx, 12) + self.state = 3654 + self.match(PLpgSQLParser.TRUNCATE) + pass + elif token in [PLpgSQLParser.USAGE]: + self.enterOuterAlt(localctx, 13) + self.state = 3655 + self.match(PLpgSQLParser.USAGE) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Other_rulesContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GRANT(self): + return self.getToken(PLpgSQLParser.GRANT, 0) + + def names_references(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Names_referencesContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Names_referencesContext,i) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def ADMIN(self): + return self.getToken(PLpgSQLParser.ADMIN, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def REVOKE(self): + return self.getToken(PLpgSQLParser.REVOKE, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_other_rules + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOther_rules" ): + listener.enterOther_rules(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOther_rules" ): + listener.exitOther_rules(self) + + + + + def other_rules(self): + + localctx = PLpgSQLParser.Other_rulesContext(self, self._ctx, self.state) + self.enterRule(localctx, 290, self.RULE_other_rules) + self._la = 0 # Token type + try: + self.state = 3679 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.GRANT]: + self.enterOuterAlt(localctx, 1) + self.state = 3658 + self.match(PLpgSQLParser.GRANT) + self.state = 3659 + self.names_references() + self.state = 3660 + self.match(PLpgSQLParser.TO) + self.state = 3661 + self.names_references() + self.state = 3665 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 3662 + self.match(PLpgSQLParser.WITH) + self.state = 3663 + self.match(PLpgSQLParser.ADMIN) + self.state = 3664 + self.match(PLpgSQLParser.OPTION) + + + pass + elif token in [PLpgSQLParser.REVOKE]: + self.enterOuterAlt(localctx, 2) + self.state = 3667 + self.match(PLpgSQLParser.REVOKE) + self.state = 3671 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,408,self._ctx) + if la_ == 1: + self.state = 3668 + self.match(PLpgSQLParser.ADMIN) + self.state = 3669 + self.match(PLpgSQLParser.OPTION) + self.state = 3670 + self.match(PLpgSQLParser.FOR) + + + self.state = 3673 + self.names_references() + self.state = 3674 + self.match(PLpgSQLParser.FROM) + self.state = 3675 + self.names_references() + self.state = 3677 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 3676 + self.cascade_restrict() + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Grant_to_ruleContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def roles_names(self): + return self.getTypedRuleContext(PLpgSQLParser.Roles_namesContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def GRANT(self): + return self.getToken(PLpgSQLParser.GRANT, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_grant_to_rule + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGrant_to_rule" ): + listener.enterGrant_to_rule(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGrant_to_rule" ): + listener.exitGrant_to_rule(self) + + + + + def grant_to_rule(self): + + localctx = PLpgSQLParser.Grant_to_ruleContext(self, self._ctx, self.state) + self.enterRule(localctx, 292, self.RULE_grant_to_rule) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3681 + self.match(PLpgSQLParser.TO) + self.state = 3682 + self.roles_names() + self.state = 3686 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 3683 + self.match(PLpgSQLParser.WITH) + self.state = 3684 + self.match(PLpgSQLParser.GRANT) + self.state = 3685 + self.match(PLpgSQLParser.OPTION) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Revoke_from_cascade_restrictContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def roles_names(self): + return self.getTypedRuleContext(PLpgSQLParser.Roles_namesContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_revoke_from_cascade_restrict + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRevoke_from_cascade_restrict" ): + listener.enterRevoke_from_cascade_restrict(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRevoke_from_cascade_restrict" ): + listener.exitRevoke_from_cascade_restrict(self) + + + + + def revoke_from_cascade_restrict(self): + + localctx = PLpgSQLParser.Revoke_from_cascade_restrictContext(self, self._ctx, self.state) + self.enterRule(localctx, 294, self.RULE_revoke_from_cascade_restrict) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3688 + self.match(PLpgSQLParser.FROM) + self.state = 3689 + self.roles_names() + self.state = 3691 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 3690 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Roles_namesContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def role_name_with_group(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Role_name_with_groupContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Role_name_with_groupContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_roles_names + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRoles_names" ): + listener.enterRoles_names(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRoles_names" ): + listener.exitRoles_names(self) + + + + + def roles_names(self): + + localctx = PLpgSQLParser.Roles_namesContext(self, self._ctx, self.state) + self.enterRule(localctx, 296, self.RULE_roles_names) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3693 + self.role_name_with_group() + self.state = 3698 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3694 + self.match(PLpgSQLParser.COMMA) + self.state = 3695 + self.role_name_with_group() + self.state = 3700 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Role_name_with_groupContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_role_name_with_group + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRole_name_with_group" ): + listener.enterRole_name_with_group(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRole_name_with_group" ): + listener.exitRole_name_with_group(self) + + + + + def role_name_with_group(self): + + localctx = PLpgSQLParser.Role_name_with_groupContext(self, self._ctx, self.state) + self.enterRule(localctx, 298, self.RULE_role_name_with_group) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3702 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GROUP: + self.state = 3701 + self.match(PLpgSQLParser.GROUP) + + + self.state = 3704 + self.user_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Comment_on_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMENT(self): + return self.getToken(PLpgSQLParser.COMMENT, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def comment_member_object(self): + return self.getTypedRuleContext(PLpgSQLParser.Comment_member_objectContext,0) + + + def IS(self): + return self.getToken(PLpgSQLParser.IS, 0) + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_comment_on_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComment_on_statement" ): + listener.enterComment_on_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComment_on_statement" ): + listener.exitComment_on_statement(self) + + + + + def comment_on_statement(self): + + localctx = PLpgSQLParser.Comment_on_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 300, self.RULE_comment_on_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3706 + self.match(PLpgSQLParser.COMMENT) + self.state = 3707 + self.match(PLpgSQLParser.ON) + self.state = 3708 + self.comment_member_object() + self.state = 3709 + self.match(PLpgSQLParser.IS) + self.state = 3712 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 3710 + self.character_string() + pass + elif token in [PLpgSQLParser.NULL]: + self.state = 3711 + self.match(PLpgSQLParser.NULL) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Security_labelContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SECURITY(self): + return self.getToken(PLpgSQLParser.SECURITY, 0) + + def LABEL(self): + return self.getToken(PLpgSQLParser.LABEL, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def label_member_object(self): + return self.getTypedRuleContext(PLpgSQLParser.Label_member_objectContext,0) + + + def IS(self): + return self.getToken(PLpgSQLParser.IS, 0) + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_security_label + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSecurity_label" ): + listener.enterSecurity_label(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSecurity_label" ): + listener.exitSecurity_label(self) + + + + + def security_label(self): + + localctx = PLpgSQLParser.Security_labelContext(self, self._ctx, self.state) + self.enterRule(localctx, 302, self.RULE_security_label) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3714 + self.match(PLpgSQLParser.SECURITY) + self.state = 3715 + self.match(PLpgSQLParser.LABEL) + self.state = 3721 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 3716 + self.match(PLpgSQLParser.FOR) + self.state = 3719 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 3717 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 3718 + self.character_string() + pass + else: + raise NoViableAltException(self) + + + + self.state = 3723 + self.match(PLpgSQLParser.ON) + self.state = 3724 + self.label_member_object() + self.state = 3725 + self.match(PLpgSQLParser.IS) + self.state = 3728 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 3726 + self.character_string() + pass + elif token in [PLpgSQLParser.NULL]: + self.state = 3727 + self.match(PLpgSQLParser.NULL) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Comment_member_objectContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.source = None # Data_typeContext + self.target = None # Data_typeContext + self.table_name = None # Schema_qualified_nameContext + self.index_method = None # IdentifierContext + + def ACCESS(self): + return self.getToken(PLpgSQLParser.ACCESS, 0) + + def METHOD(self): + return self.getToken(PLpgSQLParser.METHOD, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def ROUTINE(self): + return self.getToken(PLpgSQLParser.ROUTINE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def CAST(self): + return self.getToken(PLpgSQLParser.CAST, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def CONVERSION(self): + return self.getToken(PLpgSQLParser.CONVERSION, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def LARGE(self): + return self.getToken(PLpgSQLParser.LARGE, 0) + + def OBJECT(self): + return self.getToken(PLpgSQLParser.OBJECT, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def target_operator(self): + return self.getTypedRuleContext(PLpgSQLParser.Target_operatorContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def CLASS(self): + return self.getToken(PLpgSQLParser.CLASS, 0) + + def POLICY(self): + return self.getToken(PLpgSQLParser.POLICY, 0) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def RULE(self): + return self.getToken(PLpgSQLParser.RULE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def SUBSCRIPTION(self): + return self.getToken(PLpgSQLParser.SUBSCRIPTION, 0) + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def TRANSFORM(self): + return self.getToken(PLpgSQLParser.TRANSFORM, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_comment_member_object + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComment_member_object" ): + listener.enterComment_member_object(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComment_member_object" ): + listener.exitComment_member_object(self) + + + + + def comment_member_object(self): + + localctx = PLpgSQLParser.Comment_member_objectContext(self, self._ctx, self.state) + self.enterRule(localctx, 304, self.RULE_comment_member_object) + self._la = 0 # Token type + try: + self.state = 3854 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,423,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3730 + self.match(PLpgSQLParser.ACCESS) + self.state = 3731 + self.match(PLpgSQLParser.METHOD) + self.state = 3732 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3733 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.AGGREGATE or _la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE or _la==PLpgSQLParser.ROUTINE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3734 + localctx.name = self.schema_qualified_name() + self.state = 3735 + self.function_args() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3737 + self.match(PLpgSQLParser.CAST) + self.state = 3738 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3739 + localctx.source = self.data_type() + self.state = 3740 + self.match(PLpgSQLParser.AS) + self.state = 3741 + localctx.target = self.data_type() + self.state = 3742 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3744 + self.match(PLpgSQLParser.COLLATION) + self.state = 3745 + self.identifier() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3746 + self.match(PLpgSQLParser.COLUMN) + self.state = 3747 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3748 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 3749 + self.identifier() + self.state = 3750 + self.match(PLpgSQLParser.ON) + self.state = 3752 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,419,self._ctx) + if la_ == 1: + self.state = 3751 + self.match(PLpgSQLParser.DOMAIN) + + + self.state = 3754 + localctx.table_name = self.schema_qualified_name() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 3756 + self.match(PLpgSQLParser.CONVERSION) + self.state = 3757 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 3758 + self.match(PLpgSQLParser.DATABASE) + self.state = 3759 + self.identifier() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 3760 + self.match(PLpgSQLParser.DOMAIN) + self.state = 3761 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 3762 + self.match(PLpgSQLParser.EXTENSION) + self.state = 3763 + self.identifier() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 3764 + self.match(PLpgSQLParser.EVENT) + self.state = 3765 + self.match(PLpgSQLParser.TRIGGER) + self.state = 3766 + self.identifier() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 3767 + self.match(PLpgSQLParser.FOREIGN) + self.state = 3768 + self.match(PLpgSQLParser.DATA) + self.state = 3769 + self.match(PLpgSQLParser.WRAPPER) + self.state = 3770 + self.identifier() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 3772 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOREIGN: + self.state = 3771 + self.match(PLpgSQLParser.FOREIGN) + + + self.state = 3774 + self.match(PLpgSQLParser.TABLE) + self.state = 3775 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 3776 + self.match(PLpgSQLParser.INDEX) + self.state = 3777 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 3778 + self.match(PLpgSQLParser.LARGE) + self.state = 3779 + self.match(PLpgSQLParser.OBJECT) + self.state = 3780 + self.match(PLpgSQLParser.NUMBER_LITERAL) + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 3782 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 3781 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 3784 + self.match(PLpgSQLParser.VIEW) + self.state = 3785 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 17: + self.enterOuterAlt(localctx, 17) + self.state = 3786 + self.match(PLpgSQLParser.OPERATOR) + self.state = 3787 + self.target_operator() + pass + + elif la_ == 18: + self.enterOuterAlt(localctx, 18) + self.state = 3788 + self.match(PLpgSQLParser.OPERATOR) + self.state = 3789 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CLASS or _la==PLpgSQLParser.FAMILY): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3790 + localctx.name = self.schema_qualified_name() + self.state = 3791 + self.match(PLpgSQLParser.USING) + self.state = 3792 + localctx.index_method = self.identifier() + pass + + elif la_ == 19: + self.enterOuterAlt(localctx, 19) + self.state = 3794 + self.match(PLpgSQLParser.POLICY) + self.state = 3795 + self.identifier() + self.state = 3796 + self.match(PLpgSQLParser.ON) + self.state = 3797 + localctx.table_name = self.schema_qualified_name() + pass + + elif la_ == 20: + self.enterOuterAlt(localctx, 20) + self.state = 3800 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROCEDURAL: + self.state = 3799 + self.match(PLpgSQLParser.PROCEDURAL) + + + self.state = 3802 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 3803 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 21: + self.enterOuterAlt(localctx, 21) + self.state = 3804 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 3805 + self.identifier() + pass + + elif la_ == 22: + self.enterOuterAlt(localctx, 22) + self.state = 3806 + self.match(PLpgSQLParser.ROLE) + self.state = 3807 + self.identifier() + pass + + elif la_ == 23: + self.enterOuterAlt(localctx, 23) + self.state = 3808 + self.match(PLpgSQLParser.RULE) + self.state = 3809 + self.identifier() + self.state = 3810 + self.match(PLpgSQLParser.ON) + self.state = 3811 + localctx.table_name = self.schema_qualified_name() + pass + + elif la_ == 24: + self.enterOuterAlt(localctx, 24) + self.state = 3813 + self.match(PLpgSQLParser.SCHEMA) + self.state = 3814 + self.identifier() + pass + + elif la_ == 25: + self.enterOuterAlt(localctx, 25) + self.state = 3815 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 3816 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 26: + self.enterOuterAlt(localctx, 26) + self.state = 3817 + self.match(PLpgSQLParser.SERVER) + self.state = 3818 + self.identifier() + pass + + elif la_ == 27: + self.enterOuterAlt(localctx, 27) + self.state = 3819 + self.match(PLpgSQLParser.STATISTICS) + self.state = 3820 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 28: + self.enterOuterAlt(localctx, 28) + self.state = 3821 + self.match(PLpgSQLParser.SUBSCRIPTION) + self.state = 3822 + self.identifier() + pass + + elif la_ == 29: + self.enterOuterAlt(localctx, 29) + self.state = 3823 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 3824 + self.identifier() + pass + + elif la_ == 30: + self.enterOuterAlt(localctx, 30) + self.state = 3825 + self.match(PLpgSQLParser.TEXT) + self.state = 3826 + self.match(PLpgSQLParser.SEARCH) + self.state = 3827 + self.match(PLpgSQLParser.CONFIGURATION) + self.state = 3828 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 31: + self.enterOuterAlt(localctx, 31) + self.state = 3829 + self.match(PLpgSQLParser.TEXT) + self.state = 3830 + self.match(PLpgSQLParser.SEARCH) + self.state = 3831 + self.match(PLpgSQLParser.DICTIONARY) + self.state = 3832 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 32: + self.enterOuterAlt(localctx, 32) + self.state = 3833 + self.match(PLpgSQLParser.TEXT) + self.state = 3834 + self.match(PLpgSQLParser.SEARCH) + self.state = 3835 + self.match(PLpgSQLParser.PARSER) + self.state = 3836 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 33: + self.enterOuterAlt(localctx, 33) + self.state = 3837 + self.match(PLpgSQLParser.TEXT) + self.state = 3838 + self.match(PLpgSQLParser.SEARCH) + self.state = 3839 + self.match(PLpgSQLParser.TEMPLATE) + self.state = 3840 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 34: + self.enterOuterAlt(localctx, 34) + self.state = 3841 + self.match(PLpgSQLParser.TRANSFORM) + self.state = 3842 + self.match(PLpgSQLParser.FOR) + self.state = 3843 + localctx.name = self.schema_qualified_name() + self.state = 3844 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 3845 + self.identifier() + pass + + elif la_ == 35: + self.enterOuterAlt(localctx, 35) + self.state = 3847 + self.match(PLpgSQLParser.TRIGGER) + self.state = 3848 + self.identifier() + self.state = 3849 + self.match(PLpgSQLParser.ON) + self.state = 3850 + localctx.table_name = self.schema_qualified_name() + pass + + elif la_ == 36: + self.enterOuterAlt(localctx, 36) + self.state = 3852 + self.match(PLpgSQLParser.TYPE) + self.state = 3853 + localctx.name = self.schema_qualified_name() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Label_member_objectContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def ROUTINE(self): + return self.getToken(PLpgSQLParser.ROUTINE, 0) + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def LARGE(self): + return self.getToken(PLpgSQLParser.LARGE, 0) + + def OBJECT(self): + return self.getToken(PLpgSQLParser.OBJECT, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def SUBSCRIPTION(self): + return self.getToken(PLpgSQLParser.SUBSCRIPTION, 0) + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_label_member_object + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLabel_member_object" ): + listener.enterLabel_member_object(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLabel_member_object" ): + listener.exitLabel_member_object(self) + + + + + def label_member_object(self): + + localctx = PLpgSQLParser.Label_member_objectContext(self, self._ctx, self.state) + self.enterRule(localctx, 306, self.RULE_label_member_object) + self._la = 0 # Token type + try: + self.state = 3901 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.AGGREGATE, PLpgSQLParser.FUNCTION, PLpgSQLParser.PROCEDURE, PLpgSQLParser.ROUTINE]: + self.enterOuterAlt(localctx, 1) + self.state = 3856 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.AGGREGATE or _la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE or _la==PLpgSQLParser.ROUTINE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3857 + self.schema_qualified_name() + self.state = 3858 + self.function_args() + pass + elif token in [PLpgSQLParser.COLUMN]: + self.enterOuterAlt(localctx, 2) + self.state = 3860 + self.match(PLpgSQLParser.COLUMN) + self.state = 3861 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.DATABASE]: + self.enterOuterAlt(localctx, 3) + self.state = 3862 + self.match(PLpgSQLParser.DATABASE) + self.state = 3863 + self.identifier() + pass + elif token in [PLpgSQLParser.DOMAIN]: + self.enterOuterAlt(localctx, 4) + self.state = 3864 + self.match(PLpgSQLParser.DOMAIN) + self.state = 3865 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.EVENT]: + self.enterOuterAlt(localctx, 5) + self.state = 3866 + self.match(PLpgSQLParser.EVENT) + self.state = 3867 + self.match(PLpgSQLParser.TRIGGER) + self.state = 3868 + self.identifier() + pass + elif token in [PLpgSQLParser.FOREIGN, PLpgSQLParser.TABLE]: + self.enterOuterAlt(localctx, 6) + self.state = 3870 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOREIGN: + self.state = 3869 + self.match(PLpgSQLParser.FOREIGN) + + + self.state = 3872 + self.match(PLpgSQLParser.TABLE) + self.state = 3873 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.LARGE]: + self.enterOuterAlt(localctx, 7) + self.state = 3874 + self.match(PLpgSQLParser.LARGE) + self.state = 3875 + self.match(PLpgSQLParser.OBJECT) + self.state = 3876 + self.match(PLpgSQLParser.NUMBER_LITERAL) + pass + elif token in [PLpgSQLParser.MATERIALIZED, PLpgSQLParser.VIEW]: + self.enterOuterAlt(localctx, 8) + self.state = 3878 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 3877 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 3880 + self.match(PLpgSQLParser.VIEW) + self.state = 3881 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.LANGUAGE, PLpgSQLParser.PROCEDURAL]: + self.enterOuterAlt(localctx, 9) + self.state = 3883 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROCEDURAL: + self.state = 3882 + self.match(PLpgSQLParser.PROCEDURAL) + + + self.state = 3885 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 3886 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.PUBLICATION]: + self.enterOuterAlt(localctx, 10) + self.state = 3887 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 3888 + self.identifier() + pass + elif token in [PLpgSQLParser.ROLE]: + self.enterOuterAlt(localctx, 11) + self.state = 3889 + self.match(PLpgSQLParser.ROLE) + self.state = 3890 + self.identifier() + pass + elif token in [PLpgSQLParser.SCHEMA]: + self.enterOuterAlt(localctx, 12) + self.state = 3891 + self.match(PLpgSQLParser.SCHEMA) + self.state = 3892 + self.identifier() + pass + elif token in [PLpgSQLParser.SEQUENCE]: + self.enterOuterAlt(localctx, 13) + self.state = 3893 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 3894 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.SUBSCRIPTION]: + self.enterOuterAlt(localctx, 14) + self.state = 3895 + self.match(PLpgSQLParser.SUBSCRIPTION) + self.state = 3896 + self.identifier() + pass + elif token in [PLpgSQLParser.TABLESPACE]: + self.enterOuterAlt(localctx, 15) + self.state = 3897 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 3898 + self.identifier() + pass + elif token in [PLpgSQLParser.TYPE]: + self.enterOuterAlt(localctx, 16) + self.state = 3899 + self.match(PLpgSQLParser.TYPE) + self.state = 3900 + self.schema_qualified_name() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_function_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.rettype_data = None # Data_typeContext + self.ret_table = None # Function_ret_tableContext + + def function_parameters(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_parametersContext,0) + + + def create_funct_params(self): + return self.getTypedRuleContext(PLpgSQLParser.Create_funct_paramsContext,0) + + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def RETURNS(self): + return self.getToken(PLpgSQLParser.RETURNS, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def function_ret_table(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_ret_tableContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_function_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_function_statement" ): + listener.enterCreate_function_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_function_statement" ): + listener.exitCreate_function_statement(self) + + + + + def create_function_statement(self): + + localctx = PLpgSQLParser.Create_function_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 308, self.RULE_create_function_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3905 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 3903 + self.match(PLpgSQLParser.OR) + self.state = 3904 + self.match(PLpgSQLParser.REPLACE) + + + self.state = 3907 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3908 + self.function_parameters() + self.state = 3914 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,430,self._ctx) + if la_ == 1: + self.state = 3909 + self.match(PLpgSQLParser.RETURNS) + self.state = 3912 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 3910 + localctx.rettype_data = self.data_type() + pass + elif token in [PLpgSQLParser.TABLE]: + self.state = 3911 + localctx.ret_table = self.function_ret_table() + pass + else: + raise NoViableAltException(self) + + + + self.state = 3916 + self.create_funct_params() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_funct_paramsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def function_actions_common(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_actions_commonContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_actions_commonContext,i) + + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_funct_params + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_funct_params" ): + listener.enterCreate_funct_params(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_funct_params" ): + listener.exitCreate_funct_params(self) + + + + + def create_funct_params(self): + + localctx = PLpgSQLParser.Create_funct_paramsContext(self, self._ctx, self.state) + self.enterRule(localctx, 310, self.RULE_create_funct_params) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3919 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3918 + self.function_actions_common() + self.state = 3921 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.CALLED or _la==PLpgSQLParser.COST or ((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (PLpgSQLParser.EXTERNAL - 85)) | (1 << (PLpgSQLParser.IMMUTABLE - 85)) | (1 << (PLpgSQLParser.LANGUAGE - 85)) | (1 << (PLpgSQLParser.LEAKPROOF - 85)))) != 0) or ((((_la - 169)) & ~0x3f) == 0 and ((1 << (_la - 169)) & ((1 << (PLpgSQLParser.PARALLEL - 169)) | (1 << (PLpgSQLParser.RETURNS - 169)) | (1 << (PLpgSQLParser.ROWS - 169)) | (1 << (PLpgSQLParser.SECURITY - 169)) | (1 << (PLpgSQLParser.SET - 169)))) != 0) or ((((_la - 236)) & ~0x3f) == 0 and ((1 << (_la - 236)) & ((1 << (PLpgSQLParser.STABLE - 236)) | (1 << (PLpgSQLParser.STRICT - 236)) | (1 << (PLpgSQLParser.SUPPORT - 236)) | (1 << (PLpgSQLParser.TRANSFORM - 236)) | (1 << (PLpgSQLParser.VOLATILE - 236)))) != 0) or _la==PLpgSQLParser.AS or _la==PLpgSQLParser.NOT or _la==PLpgSQLParser.WINDOW): + break + + self.state = 3924 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 3923 + self.with_storage_parameter() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Transform_for_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_transform_for_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTransform_for_type" ): + listener.enterTransform_for_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTransform_for_type" ): + listener.exitTransform_for_type(self) + + + + + def transform_for_type(self): + + localctx = PLpgSQLParser.Transform_for_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 312, self.RULE_transform_for_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3926 + self.match(PLpgSQLParser.FOR) + self.state = 3927 + self.match(PLpgSQLParser.TYPE) + self.state = 3928 + self.data_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_ret_tableContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def function_column_name_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_column_name_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_column_name_typeContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_ret_table + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_ret_table" ): + listener.enterFunction_ret_table(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_ret_table" ): + listener.exitFunction_ret_table(self) + + + + + def function_ret_table(self): + + localctx = PLpgSQLParser.Function_ret_tableContext(self, self._ctx, self.state) + self.enterRule(localctx, 314, self.RULE_function_ret_table) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3930 + self.match(PLpgSQLParser.TABLE) + self.state = 3931 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3932 + self.function_column_name_type() + self.state = 3937 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3933 + self.match(PLpgSQLParser.COMMA) + self.state = 3934 + self.function_column_name_type() + self.state = 3939 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3940 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_column_name_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_column_name_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_column_name_type" ): + listener.enterFunction_column_name_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_column_name_type" ): + listener.exitFunction_column_name_type(self) + + + + + def function_column_name_type(self): + + localctx = PLpgSQLParser.Function_column_name_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 316, self.RULE_function_column_name_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3942 + self.identifier() + self.state = 3943 + self.data_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_parametersContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_parameters + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_parameters" ): + listener.enterFunction_parameters(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_parameters" ): + listener.exitFunction_parameters(self) + + + + + def function_parameters(self): + + localctx = PLpgSQLParser.Function_parametersContext(self, self._ctx, self.state) + self.enterRule(localctx, 318, self.RULE_function_parameters) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3945 + self.schema_qualified_name() + self.state = 3946 + self.function_args() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_argsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def function_arguments(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_argumentsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_argumentsContext,i) + + + def agg_order(self): + return self.getTypedRuleContext(PLpgSQLParser.Agg_orderContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_args + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_args" ): + listener.enterFunction_args(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_args" ): + listener.exitFunction_args(self) + + + + + def function_args(self): + + localctx = PLpgSQLParser.Function_argsContext(self, self._ctx, self.state) + self.enterRule(localctx, 320, self.RULE_function_args) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3948 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 3963 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.IN, PLpgSQLParser.ORDER, PLpgSQLParser.VARIADIC, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.RIGHT_PAREN, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 3957 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)))) != 0) or ((((_la - 405)) & ~0x3f) == 0 and ((1 << (_la - 405)) & ((1 << (PLpgSQLParser.IN - 405)) | (1 << (PLpgSQLParser.VARIADIC - 405)) | (1 << (PLpgSQLParser.ALIGNMENT - 405)) | (1 << (PLpgSQLParser.BASETYPE - 405)) | (1 << (PLpgSQLParser.BUFFERS - 405)) | (1 << (PLpgSQLParser.BYPASSRLS - 405)) | (1 << (PLpgSQLParser.CANONICAL - 405)) | (1 << (PLpgSQLParser.CATEGORY - 405)) | (1 << (PLpgSQLParser.COLLATABLE - 405)) | (1 << (PLpgSQLParser.COMBINEFUNC - 405)) | (1 << (PLpgSQLParser.COMMUTATOR - 405)) | (1 << (PLpgSQLParser.CONNECT - 405)) | (1 << (PLpgSQLParser.COSTS - 405)) | (1 << (PLpgSQLParser.CREATEDB - 405)) | (1 << (PLpgSQLParser.CREATEROLE - 405)) | (1 << (PLpgSQLParser.DESERIALFUNC - 405)) | (1 << (PLpgSQLParser.DETERMINISTIC - 405)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 405)) | (1 << (PLpgSQLParser.ELEMENT - 405)) | (1 << (PLpgSQLParser.EXTENDED - 405)) | (1 << (PLpgSQLParser.FINALFUNC - 405)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 405)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 405)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 405)) | (1 << (PLpgSQLParser.FORCE_NULL - 405)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 405)) | (1 << (PLpgSQLParser.FORMAT - 405)) | (1 << (PLpgSQLParser.GETTOKEN - 405)))) != 0) or ((((_la - 469)) & ~0x3f) == 0 and ((1 << (_la - 469)) & ((1 << (PLpgSQLParser.HASH - 469)) | (1 << (PLpgSQLParser.HASHES - 469)) | (1 << (PLpgSQLParser.HEADLINE - 469)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 469)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 469)) | (1 << (PLpgSQLParser.INIT - 469)) | (1 << (PLpgSQLParser.INITCOND - 469)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 469)) | (1 << (PLpgSQLParser.JSON - 469)) | (1 << (PLpgSQLParser.LC_COLLATE - 469)) | (1 << (PLpgSQLParser.LC_CTYPE - 469)) | (1 << (PLpgSQLParser.LEFTARG - 469)) | (1 << (PLpgSQLParser.LEXIZE - 469)) | (1 << (PLpgSQLParser.LEXTYPES - 469)) | (1 << (PLpgSQLParser.LIST - 469)) | (1 << (PLpgSQLParser.LOCALE - 469)) | (1 << (PLpgSQLParser.LOGIN - 469)) | (1 << (PLpgSQLParser.MAIN - 469)) | (1 << (PLpgSQLParser.MERGES - 469)) | (1 << (PLpgSQLParser.MFINALFUNC - 469)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 469)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 469)) | (1 << (PLpgSQLParser.MINITCOND - 469)) | (1 << (PLpgSQLParser.MINVFUNC - 469)) | (1 << (PLpgSQLParser.MODULUS - 469)) | (1 << (PLpgSQLParser.MSFUNC - 469)) | (1 << (PLpgSQLParser.MSSPACE - 469)) | (1 << (PLpgSQLParser.MSTYPE - 469)) | (1 << (PLpgSQLParser.NEGATOR - 469)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 469)) | (1 << (PLpgSQLParser.NOCREATEDB - 469)) | (1 << (PLpgSQLParser.NOCREATEROLE - 469)) | (1 << (PLpgSQLParser.NOINHERIT - 469)) | (1 << (PLpgSQLParser.NOLOGIN - 469)) | (1 << (PLpgSQLParser.NOREPLICATION - 469)) | (1 << (PLpgSQLParser.NOSUPERUSER - 469)) | (1 << (PLpgSQLParser.OUTPUT - 469)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 469)) | (1 << (PLpgSQLParser.PATH - 469)) | (1 << (PLpgSQLParser.PERMISSIVE - 469)) | (1 << (PLpgSQLParser.PLAIN - 469)) | (1 << (PLpgSQLParser.PREFERRED - 469)) | (1 << (PLpgSQLParser.PROVIDER - 469)) | (1 << (PLpgSQLParser.READ_ONLY - 469)) | (1 << (PLpgSQLParser.READ_WRITE - 469)) | (1 << (PLpgSQLParser.RECEIVE - 469)) | (1 << (PLpgSQLParser.REMAINDER - 469)) | (1 << (PLpgSQLParser.REPLICATION - 469)) | (1 << (PLpgSQLParser.RESTRICTED - 469)) | (1 << (PLpgSQLParser.RESTRICTIVE - 469)) | (1 << (PLpgSQLParser.RIGHTARG - 469)) | (1 << (PLpgSQLParser.SAFE - 469)) | (1 << (PLpgSQLParser.SEND - 469)) | (1 << (PLpgSQLParser.SERIALFUNC - 469)) | (1 << (PLpgSQLParser.SETTINGS - 469)) | (1 << (PLpgSQLParser.SFUNC - 469)) | (1 << (PLpgSQLParser.SHAREABLE - 469)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 469)) | (1 << (PLpgSQLParser.SORTOP - 469)) | (1 << (PLpgSQLParser.SSPACE - 469)) | (1 << (PLpgSQLParser.STYPE - 469)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 469)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 469)) | (1 << (PLpgSQLParser.SUBTYPE - 469)))) != 0) or ((((_la - 533)) & ~0x3f) == 0 and ((1 << (_la - 533)) & ((1 << (PLpgSQLParser.SUMMARY - 533)) | (1 << (PLpgSQLParser.SUPERUSER - 533)) | (1 << (PLpgSQLParser.TIMING - 533)) | (1 << (PLpgSQLParser.TYPMOD_IN - 533)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 533)) | (1 << (PLpgSQLParser.UNSAFE - 533)) | (1 << (PLpgSQLParser.USAGE - 533)) | (1 << (PLpgSQLParser.VARIABLE - 533)) | (1 << (PLpgSQLParser.YAML - 533)) | (1 << (PLpgSQLParser.ALIAS - 533)) | (1 << (PLpgSQLParser.ASSERT - 533)) | (1 << (PLpgSQLParser.CONSTANT - 533)) | (1 << (PLpgSQLParser.DATATYPE - 533)) | (1 << (PLpgSQLParser.DEBUG - 533)) | (1 << (PLpgSQLParser.DETAIL - 533)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 533)) | (1 << (PLpgSQLParser.ELSEIF - 533)) | (1 << (PLpgSQLParser.ELSIF - 533)) | (1 << (PLpgSQLParser.ERRCODE - 533)) | (1 << (PLpgSQLParser.EXIT - 533)) | (1 << (PLpgSQLParser.EXCEPTION - 533)) | (1 << (PLpgSQLParser.FOREACH - 533)) | (1 << (PLpgSQLParser.GET - 533)) | (1 << (PLpgSQLParser.HINT - 533)) | (1 << (PLpgSQLParser.INFO - 533)) | (1 << (PLpgSQLParser.LOG - 533)) | (1 << (PLpgSQLParser.LOOP - 533)) | (1 << (PLpgSQLParser.MESSAGE - 533)) | (1 << (PLpgSQLParser.NOTICE - 533)) | (1 << (PLpgSQLParser.OPEN - 533)) | (1 << (PLpgSQLParser.PERFORM - 533)) | (1 << (PLpgSQLParser.QUERY - 533)) | (1 << (PLpgSQLParser.RAISE - 533)) | (1 << (PLpgSQLParser.RECORD - 533)) | (1 << (PLpgSQLParser.RETURN - 533)) | (1 << (PLpgSQLParser.REVERSE - 533)) | (1 << (PLpgSQLParser.ROWTYPE - 533)) | (1 << (PLpgSQLParser.SLICE - 533)) | (1 << (PLpgSQLParser.SQLSTATE - 533)) | (1 << (PLpgSQLParser.STACKED - 533)) | (1 << (PLpgSQLParser.WARNING - 533)) | (1 << (PLpgSQLParser.WHILE - 533)))) != 0) or _la==PLpgSQLParser.Identifier or _la==PLpgSQLParser.QuotedIdentifier: + self.state = 3949 + self.function_arguments() + self.state = 3954 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3950 + self.match(PLpgSQLParser.COMMA) + self.state = 3951 + self.function_arguments() + self.state = 3956 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 3960 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ORDER: + self.state = 3959 + self.agg_order() + + + pass + elif token in [PLpgSQLParser.MULTIPLY]: + self.state = 3962 + self.match(PLpgSQLParser.MULTIPLY) + pass + else: + raise NoViableAltException(self) + + self.state = 3965 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Agg_orderContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ORDER(self): + return self.getToken(PLpgSQLParser.ORDER, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def function_arguments(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_argumentsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_argumentsContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_agg_order + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAgg_order" ): + listener.enterAgg_order(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAgg_order" ): + listener.exitAgg_order(self) + + + + + def agg_order(self): + + localctx = PLpgSQLParser.Agg_orderContext(self, self._ctx, self.state) + self.enterRule(localctx, 322, self.RULE_agg_order) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3967 + self.match(PLpgSQLParser.ORDER) + self.state = 3968 + self.match(PLpgSQLParser.BY) + self.state = 3969 + self.function_arguments() + self.state = 3974 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 3970 + self.match(PLpgSQLParser.COMMA) + self.state = 3971 + self.function_arguments() + self.state = 3976 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Character_stringContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BeginDollarStringConstant(self): + return self.getToken(PLpgSQLParser.BeginDollarStringConstant, 0) + + def EndDollarStringConstant(self): + return self.getToken(PLpgSQLParser.EndDollarStringConstant, 0) + + def Text_between_Dollar(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.Text_between_Dollar) + else: + return self.getToken(PLpgSQLParser.Text_between_Dollar, i) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_character_string + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCharacter_string" ): + listener.enterCharacter_string(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCharacter_string" ): + listener.exitCharacter_string(self) + + + + + def character_string(self): + + localctx = PLpgSQLParser.Character_stringContext(self, self._ctx, self.state) + self.enterRule(localctx, 324, self.RULE_character_string) + self._la = 0 # Token type + try: + self.state = 3986 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.BeginDollarStringConstant]: + self.enterOuterAlt(localctx, 1) + self.state = 3977 + self.match(PLpgSQLParser.BeginDollarStringConstant) + self.state = 3981 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.Text_between_Dollar: + self.state = 3978 + self.match(PLpgSQLParser.Text_between_Dollar) + self.state = 3983 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3984 + self.match(PLpgSQLParser.EndDollarStringConstant) + pass + elif token in [PLpgSQLParser.Character_String_Literal]: + self.enterOuterAlt(localctx, 2) + self.state = 3985 + self.match(PLpgSQLParser.Character_String_Literal) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_argumentsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def argmode(self): + return self.getTypedRuleContext(PLpgSQLParser.ArgmodeContext,0) + + + def identifier_nontype(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_nontypeContext,0) + + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_arguments + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_arguments" ): + listener.enterFunction_arguments(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_arguments" ): + listener.exitFunction_arguments(self) + + + + + def function_arguments(self): + + localctx = PLpgSQLParser.Function_argumentsContext(self, self._ctx, self.state) + self.enterRule(localctx, 326, self.RULE_function_arguments) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3989 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,441,self._ctx) + if la_ == 1: + self.state = 3988 + self.argmode() + + + self.state = 3992 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,442,self._ctx) + if la_ == 1: + self.state = 3991 + self.identifier_nontype() + + + self.state = 3994 + self.data_type() + self.state = 3997 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFAULT or _la==PLpgSQLParser.EQUAL: + self.state = 3995 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DEFAULT or _la==PLpgSQLParser.EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3996 + self.vex(0) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArgmodeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def OUT(self): + return self.getToken(PLpgSQLParser.OUT, 0) + + def INOUT(self): + return self.getToken(PLpgSQLParser.INOUT, 0) + + def VARIADIC(self): + return self.getToken(PLpgSQLParser.VARIADIC, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_argmode + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArgmode" ): + listener.enterArgmode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArgmode" ): + listener.exitArgmode(self) + + + + + def argmode(self): + + localctx = PLpgSQLParser.ArgmodeContext(self, self._ctx, self.state) + self.enterRule(localctx, 328, self.RULE_argmode) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3999 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.INOUT or _la==PLpgSQLParser.OUT or _la==PLpgSQLParser.IN or _la==PLpgSQLParser.VARIADIC): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_sequence_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def sequence_body(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Sequence_bodyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Sequence_bodyContext,i) + + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_sequence_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_sequence_statement" ): + listener.enterCreate_sequence_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_sequence_statement" ): + listener.exitCreate_sequence_statement(self) + + + + + def create_sequence_statement(self): + + localctx = PLpgSQLParser.Create_sequence_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 330, self.RULE_create_sequence_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4002 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY: + self.state = 4001 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4004 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 4006 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,445,self._ctx) + if la_ == 1: + self.state = 4005 + self.if_not_exists() + + + self.state = 4008 + localctx.name = self.schema_qualified_name() + self.state = 4012 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.CACHE or _la==PLpgSQLParser.CYCLE or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (PLpgSQLParser.INCREMENT - 110)) | (1 << (PLpgSQLParser.MAXVALUE - 110)) | (1 << (PLpgSQLParser.MINVALUE - 110)) | (1 << (PLpgSQLParser.NO - 110)) | (1 << (PLpgSQLParser.OWNED - 110)))) != 0) or _la==PLpgSQLParser.SEQUENCE or _la==PLpgSQLParser.START or _la==PLpgSQLParser.AS: + self.state = 4009 + self.sequence_body() + self.state = 4014 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Sequence_bodyContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.type = None # Token + self.name = None # Schema_qualified_nameContext + self.incr = None # Signed_numerical_literalContext + self.minval = None # Signed_numerical_literalContext + self.maxval = None # Signed_numerical_literalContext + self.start_val = None # Signed_numerical_literalContext + self.cache_val = None # Signed_numerical_literalContext + self.cycle_true = None # Token + self.cycle_val = None # Token + self.col_name = None # Schema_qualified_nameContext + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def SMALLINT(self): + return self.getToken(PLpgSQLParser.SMALLINT, 0) + + def INTEGER(self): + return self.getToken(PLpgSQLParser.INTEGER, 0) + + def BIGINT(self): + return self.getToken(PLpgSQLParser.BIGINT, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def NAME(self): + return self.getToken(PLpgSQLParser.NAME, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def INCREMENT(self): + return self.getToken(PLpgSQLParser.INCREMENT, 0) + + def signed_numerical_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Signed_numerical_literalContext,0) + + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def MINVALUE(self): + return self.getToken(PLpgSQLParser.MINVALUE, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def MAXVALUE(self): + return self.getToken(PLpgSQLParser.MAXVALUE, 0) + + def START(self): + return self.getToken(PLpgSQLParser.START, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def CACHE(self): + return self.getToken(PLpgSQLParser.CACHE, 0) + + def CYCLE(self): + return self.getToken(PLpgSQLParser.CYCLE, 0) + + def OWNED(self): + return self.getToken(PLpgSQLParser.OWNED, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_sequence_body + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSequence_body" ): + listener.enterSequence_body(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSequence_body" ): + listener.exitSequence_body(self) + + + + + def sequence_body(self): + + localctx = PLpgSQLParser.Sequence_bodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 332, self.RULE_sequence_body) + self._la = 0 # Token type + try: + self.state = 4051 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,452,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4015 + self.match(PLpgSQLParser.AS) + self.state = 4016 + localctx.type = self._input.LT(1) + _la = self._input.LA(1) + if not(((((_la - 294)) & ~0x3f) == 0 and ((1 << (_la - 294)) & ((1 << (PLpgSQLParser.BIGINT - 294)) | (1 << (PLpgSQLParser.INTEGER - 294)) | (1 << (PLpgSQLParser.SMALLINT - 294)))) != 0)): + localctx.type = self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4017 + self.match(PLpgSQLParser.SEQUENCE) + self.state = 4018 + self.match(PLpgSQLParser.NAME) + self.state = 4019 + localctx.name = self.schema_qualified_name() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4020 + self.match(PLpgSQLParser.INCREMENT) + self.state = 4022 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BY: + self.state = 4021 + self.match(PLpgSQLParser.BY) + + + self.state = 4024 + localctx.incr = self.signed_numerical_literal() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 4029 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.MINVALUE]: + self.state = 4025 + self.match(PLpgSQLParser.MINVALUE) + self.state = 4026 + localctx.minval = self.signed_numerical_literal() + pass + elif token in [PLpgSQLParser.NO]: + self.state = 4027 + self.match(PLpgSQLParser.NO) + self.state = 4028 + self.match(PLpgSQLParser.MINVALUE) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 4035 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.MAXVALUE]: + self.state = 4031 + self.match(PLpgSQLParser.MAXVALUE) + self.state = 4032 + localctx.maxval = self.signed_numerical_literal() + pass + elif token in [PLpgSQLParser.NO]: + self.state = 4033 + self.match(PLpgSQLParser.NO) + self.state = 4034 + self.match(PLpgSQLParser.MAXVALUE) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 4037 + self.match(PLpgSQLParser.START) + self.state = 4039 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4038 + self.match(PLpgSQLParser.WITH) + + + self.state = 4041 + localctx.start_val = self.signed_numerical_literal() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 4042 + self.match(PLpgSQLParser.CACHE) + self.state = 4043 + localctx.cache_val = self.signed_numerical_literal() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 4045 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 4044 + localctx.cycle_true = self.match(PLpgSQLParser.NO) + + + self.state = 4047 + localctx.cycle_val = self.match(PLpgSQLParser.CYCLE) + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 4048 + self.match(PLpgSQLParser.OWNED) + self.state = 4049 + self.match(PLpgSQLParser.BY) + self.state = 4050 + localctx.col_name = self.schema_qualified_name() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Signed_number_literalContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def sign(self): + return self.getTypedRuleContext(PLpgSQLParser.SignContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_signed_number_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSigned_number_literal" ): + listener.enterSigned_number_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSigned_number_literal" ): + listener.exitSigned_number_literal(self) + + + + + def signed_number_literal(self): + + localctx = PLpgSQLParser.Signed_number_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 334, self.RULE_signed_number_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4054 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS: + self.state = 4053 + self.sign() + + + self.state = 4056 + self.match(PLpgSQLParser.NUMBER_LITERAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Signed_numerical_literalContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unsigned_numeric_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_numeric_literalContext,0) + + + def sign(self): + return self.getTypedRuleContext(PLpgSQLParser.SignContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_signed_numerical_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSigned_numerical_literal" ): + listener.enterSigned_numerical_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSigned_numerical_literal" ): + listener.exitSigned_numerical_literal(self) + + + + + def signed_numerical_literal(self): + + localctx = PLpgSQLParser.Signed_numerical_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 336, self.RULE_signed_numerical_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4059 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS: + self.state = 4058 + self.sign() + + + self.state = 4061 + self.unsigned_numeric_literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SignContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PLUS(self): + return self.getToken(PLpgSQLParser.PLUS, 0) + + def MINUS(self): + return self.getToken(PLpgSQLParser.MINUS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_sign + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSign" ): + listener.enterSign(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSign" ): + listener.exitSign(self) + + + + + def sign(self): + + localctx = PLpgSQLParser.SignContext(self, self._ctx, self.state) + self.enterRule(localctx, 338, self.RULE_sign) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4063 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_schema_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def AUTHORIZATION(self): + return self.getToken(PLpgSQLParser.AUTHORIZATION, 0) + + def user_name(self): + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_schema_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_schema_statement" ): + listener.enterCreate_schema_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_schema_statement" ): + listener.exitCreate_schema_statement(self) + + + + + def create_schema_statement(self): + + localctx = PLpgSQLParser.Create_schema_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 340, self.RULE_create_schema_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4065 + self.match(PLpgSQLParser.SCHEMA) + self.state = 4067 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,455,self._ctx) + if la_ == 1: + self.state = 4066 + self.if_not_exists() + + + self.state = 4070 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 4069 + localctx.name = self.identifier() + + + self.state = 4074 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AUTHORIZATION: + self.state = 4072 + self.match(PLpgSQLParser.AUTHORIZATION) + self.state = 4073 + self.user_name() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_policy_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.event = None # Token + self.using = None # VexContext + self.check = None # VexContext + + def POLICY(self): + return self.getToken(PLpgSQLParser.POLICY, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def user_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.User_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,i) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def CHECK(self): + return self.getToken(PLpgSQLParser.CHECK, 0) + + def PERMISSIVE(self): + return self.getToken(PLpgSQLParser.PERMISSIVE, 0) + + def RESTRICTIVE(self): + return self.getToken(PLpgSQLParser.RESTRICTIVE, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def INSERT(self): + return self.getToken(PLpgSQLParser.INSERT, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_policy_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_policy_statement" ): + listener.enterCreate_policy_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_policy_statement" ): + listener.exitCreate_policy_statement(self) + + + + + def create_policy_statement(self): + + localctx = PLpgSQLParser.Create_policy_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 342, self.RULE_create_policy_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4076 + self.match(PLpgSQLParser.POLICY) + self.state = 4077 + self.identifier() + self.state = 4078 + self.match(PLpgSQLParser.ON) + self.state = 4079 + self.schema_qualified_name() + self.state = 4082 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 4080 + self.match(PLpgSQLParser.AS) + self.state = 4081 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PERMISSIVE or _la==PLpgSQLParser.RESTRICTIVE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4086 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 4084 + self.match(PLpgSQLParser.FOR) + self.state = 4085 + localctx.event = self._input.LT(1) + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DELETE or _la==PLpgSQLParser.INSERT or _la==PLpgSQLParser.UPDATE or _la==PLpgSQLParser.ALL or _la==PLpgSQLParser.SELECT): + localctx.event = self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4097 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TO: + self.state = 4088 + self.match(PLpgSQLParser.TO) + self.state = 4089 + self.user_name() + self.state = 4094 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4090 + self.match(PLpgSQLParser.COMMA) + self.state = 4091 + self.user_name() + self.state = 4096 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 4101 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 4099 + self.match(PLpgSQLParser.USING) + self.state = 4100 + localctx.using = self.vex(0) + + + self.state = 4106 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4103 + self.match(PLpgSQLParser.WITH) + self.state = 4104 + self.match(PLpgSQLParser.CHECK) + self.state = 4105 + localctx.check = self.vex(0) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_policy_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def POLICY(self): + return self.getToken(PLpgSQLParser.POLICY, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def user_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.User_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.User_nameContext,i) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def CHECK(self): + return self.getToken(PLpgSQLParser.CHECK, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_policy_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_policy_statement" ): + listener.enterAlter_policy_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_policy_statement" ): + listener.exitAlter_policy_statement(self) + + + + + def alter_policy_statement(self): + + localctx = PLpgSQLParser.Alter_policy_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 344, self.RULE_alter_policy_statement) + self._la = 0 # Token type + try: + self.state = 4138 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,468,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4108 + self.match(PLpgSQLParser.POLICY) + self.state = 4109 + self.identifier() + self.state = 4110 + self.match(PLpgSQLParser.ON) + self.state = 4111 + self.schema_qualified_name() + self.state = 4112 + self.rename_to() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4114 + self.match(PLpgSQLParser.POLICY) + self.state = 4115 + self.identifier() + self.state = 4116 + self.match(PLpgSQLParser.ON) + self.state = 4117 + self.schema_qualified_name() + self.state = 4127 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TO: + self.state = 4118 + self.match(PLpgSQLParser.TO) + self.state = 4119 + self.user_name() + self.state = 4124 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4120 + self.match(PLpgSQLParser.COMMA) + self.state = 4121 + self.user_name() + self.state = 4126 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 4131 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 4129 + self.match(PLpgSQLParser.USING) + self.state = 4130 + self.vex(0) + + + self.state = 4136 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4133 + self.match(PLpgSQLParser.WITH) + self.state = 4134 + self.match(PLpgSQLParser.CHECK) + self.state = 4135 + self.vex(0) + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_policy_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def POLICY(self): + return self.getToken(PLpgSQLParser.POLICY, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_policy_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_policy_statement" ): + listener.enterDrop_policy_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_policy_statement" ): + listener.exitDrop_policy_statement(self) + + + + + def drop_policy_statement(self): + + localctx = PLpgSQLParser.Drop_policy_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 346, self.RULE_drop_policy_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4140 + self.match(PLpgSQLParser.POLICY) + self.state = 4142 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,469,self._ctx) + if la_ == 1: + self.state = 4141 + self.if_exists() + + + self.state = 4144 + self.identifier() + self.state = 4145 + self.match(PLpgSQLParser.ON) + self.state = 4146 + self.schema_qualified_name() + self.state = 4148 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 4147 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_subscription_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBSCRIPTION(self): + return self.getToken(PLpgSQLParser.SUBSCRIPTION, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def CONNECTION(self): + return self.getToken(PLpgSQLParser.CONNECTION, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_subscription_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_subscription_statement" ): + listener.enterCreate_subscription_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_subscription_statement" ): + listener.exitCreate_subscription_statement(self) + + + + + def create_subscription_statement(self): + + localctx = PLpgSQLParser.Create_subscription_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 348, self.RULE_create_subscription_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4150 + self.match(PLpgSQLParser.SUBSCRIPTION) + self.state = 4151 + self.identifier() + self.state = 4152 + self.match(PLpgSQLParser.CONNECTION) + self.state = 4153 + self.match(PLpgSQLParser.Character_String_Literal) + self.state = 4154 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 4155 + self.identifier_list() + self.state = 4157 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4156 + self.with_storage_parameter() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_subscription_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBSCRIPTION(self): + return self.getToken(PLpgSQLParser.SUBSCRIPTION, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def alter_subscription_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_subscription_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_subscription_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_subscription_statement" ): + listener.enterAlter_subscription_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_subscription_statement" ): + listener.exitAlter_subscription_statement(self) + + + + + def alter_subscription_statement(self): + + localctx = PLpgSQLParser.Alter_subscription_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 350, self.RULE_alter_subscription_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4159 + self.match(PLpgSQLParser.SUBSCRIPTION) + self.state = 4160 + self.identifier() + self.state = 4161 + self.alter_subscription_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_subscription_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONNECTION(self): + return self.getToken(PLpgSQLParser.CONNECTION, 0) + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def REFRESH(self): + return self.getToken(PLpgSQLParser.REFRESH, 0) + + def ENABLE(self): + return self.getToken(PLpgSQLParser.ENABLE, 0) + + def DISABLE(self): + return self.getToken(PLpgSQLParser.DISABLE, 0) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_subscription_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_subscription_action" ): + listener.enterAlter_subscription_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_subscription_action" ): + listener.exitAlter_subscription_action(self) + + + + + def alter_subscription_action(self): + + localctx = PLpgSQLParser.Alter_subscription_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 352, self.RULE_alter_subscription_action) + self._la = 0 # Token type + try: + self.state = 4182 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,474,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4163 + self.match(PLpgSQLParser.CONNECTION) + self.state = 4164 + self.character_string() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4165 + self.match(PLpgSQLParser.SET) + self.state = 4166 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 4167 + self.identifier_list() + self.state = 4169 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4168 + self.with_storage_parameter() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4171 + self.match(PLpgSQLParser.REFRESH) + self.state = 4172 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 4174 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4173 + self.with_storage_parameter() + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 4176 + self.match(PLpgSQLParser.ENABLE) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 4177 + self.match(PLpgSQLParser.DISABLE) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 4178 + self.match(PLpgSQLParser.SET) + self.state = 4179 + self.storage_parameter() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 4180 + self.owner_to() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 4181 + self.rename_to() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_cast_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.source = None # Data_typeContext + self.target = None # Data_typeContext + self.func_name = None # Schema_qualified_nameContext + + def CAST(self): + return self.getToken(PLpgSQLParser.CAST, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def AS(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.AS) + else: + return self.getToken(PLpgSQLParser.AS, i) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def WITHOUT(self): + return self.getToken(PLpgSQLParser.WITHOUT, 0) + + def INOUT(self): + return self.getToken(PLpgSQLParser.INOUT, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def ASSIGNMENT(self): + return self.getToken(PLpgSQLParser.ASSIGNMENT, 0) + + def IMPLICIT(self): + return self.getToken(PLpgSQLParser.IMPLICIT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_cast_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_cast_statement" ): + listener.enterCreate_cast_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_cast_statement" ): + listener.exitCreate_cast_statement(self) + + + + + def create_cast_statement(self): + + localctx = PLpgSQLParser.Create_cast_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 354, self.RULE_create_cast_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4184 + self.match(PLpgSQLParser.CAST) + self.state = 4185 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4186 + localctx.source = self.data_type() + self.state = 4187 + self.match(PLpgSQLParser.AS) + self.state = 4188 + localctx.target = self.data_type() + self.state = 4189 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 4199 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,475,self._ctx) + if la_ == 1: + self.state = 4190 + self.match(PLpgSQLParser.WITH) + self.state = 4191 + self.match(PLpgSQLParser.FUNCTION) + self.state = 4192 + localctx.func_name = self.schema_qualified_name() + self.state = 4193 + self.function_args() + pass + + elif la_ == 2: + self.state = 4195 + self.match(PLpgSQLParser.WITHOUT) + self.state = 4196 + self.match(PLpgSQLParser.FUNCTION) + pass + + elif la_ == 3: + self.state = 4197 + self.match(PLpgSQLParser.WITH) + self.state = 4198 + self.match(PLpgSQLParser.INOUT) + pass + + + self.state = 4205 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,476,self._ctx) + if la_ == 1: + self.state = 4201 + self.match(PLpgSQLParser.AS) + self.state = 4202 + self.match(PLpgSQLParser.ASSIGNMENT) + + elif la_ == 2: + self.state = 4203 + self.match(PLpgSQLParser.AS) + self.state = 4204 + self.match(PLpgSQLParser.IMPLICIT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_cast_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.source = None # Data_typeContext + self.target = None # Data_typeContext + + def CAST(self): + return self.getToken(PLpgSQLParser.CAST, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_cast_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_cast_statement" ): + listener.enterDrop_cast_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_cast_statement" ): + listener.exitDrop_cast_statement(self) + + + + + def drop_cast_statement(self): + + localctx = PLpgSQLParser.Drop_cast_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 356, self.RULE_drop_cast_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4207 + self.match(PLpgSQLParser.CAST) + self.state = 4209 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.IF: + self.state = 4208 + self.if_exists() + + + self.state = 4211 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4212 + localctx.source = self.data_type() + self.state = 4213 + self.match(PLpgSQLParser.AS) + self.state = 4214 + localctx.target = self.data_type() + self.state = 4215 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 4217 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 4216 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_operator_family_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_operator_family_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_operator_family_statement" ): + listener.enterCreate_operator_family_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_operator_family_statement" ): + listener.exitCreate_operator_family_statement(self) + + + + + def create_operator_family_statement(self): + + localctx = PLpgSQLParser.Create_operator_family_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 358, self.RULE_create_operator_family_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4219 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4220 + self.match(PLpgSQLParser.FAMILY) + self.state = 4221 + self.schema_qualified_name() + self.state = 4222 + self.match(PLpgSQLParser.USING) + self.state = 4223 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_operator_family_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def operator_family_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Operator_family_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_operator_family_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_operator_family_statement" ): + listener.enterAlter_operator_family_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_operator_family_statement" ): + listener.exitAlter_operator_family_statement(self) + + + + + def alter_operator_family_statement(self): + + localctx = PLpgSQLParser.Alter_operator_family_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 360, self.RULE_alter_operator_family_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4225 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4226 + self.match(PLpgSQLParser.FAMILY) + self.state = 4227 + self.schema_qualified_name() + self.state = 4228 + self.match(PLpgSQLParser.USING) + self.state = 4229 + self.identifier() + self.state = 4230 + self.operator_family_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Operator_family_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def add_operator_to_family(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Add_operator_to_familyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Add_operator_to_familyContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def drop_operator_from_family(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Drop_operator_from_familyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Drop_operator_from_familyContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_operator_family_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOperator_family_action" ): + listener.enterOperator_family_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOperator_family_action" ): + listener.exitOperator_family_action(self) + + + + + def operator_family_action(self): + + localctx = PLpgSQLParser.Operator_family_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 362, self.RULE_operator_family_action) + self._la = 0 # Token type + try: + self.state = 4253 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.enterOuterAlt(localctx, 1) + self.state = 4232 + self.rename_to() + pass + elif token in [PLpgSQLParser.OWNER]: + self.enterOuterAlt(localctx, 2) + self.state = 4233 + self.owner_to() + pass + elif token in [PLpgSQLParser.SET]: + self.enterOuterAlt(localctx, 3) + self.state = 4234 + self.set_schema() + pass + elif token in [PLpgSQLParser.ADD]: + self.enterOuterAlt(localctx, 4) + self.state = 4235 + self.match(PLpgSQLParser.ADD) + self.state = 4236 + self.add_operator_to_family() + self.state = 4241 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4237 + self.match(PLpgSQLParser.COMMA) + self.state = 4238 + self.add_operator_to_family() + self.state = 4243 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + elif token in [PLpgSQLParser.DROP]: + self.enterOuterAlt(localctx, 5) + self.state = 4244 + self.match(PLpgSQLParser.DROP) + self.state = 4245 + self.drop_operator_from_family() + self.state = 4250 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4246 + self.match(PLpgSQLParser.COMMA) + self.state = 4247 + self.drop_operator_from_family() + self.state = 4252 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Add_operator_to_familyContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def unsigned_numeric_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_numeric_literalContext,0) + + + def target_operator(self): + return self.getTypedRuleContext(PLpgSQLParser.Target_operatorContext,0) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def ORDER(self): + return self.getToken(PLpgSQLParser.ORDER, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def NONE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NONE) + else: + return self.getToken(PLpgSQLParser.NONE, i) + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_add_operator_to_family + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAdd_operator_to_family" ): + listener.enterAdd_operator_to_family(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAdd_operator_to_family" ): + listener.exitAdd_operator_to_family(self) + + + + + def add_operator_to_family(self): + + localctx = PLpgSQLParser.Add_operator_to_familyContext(self, self._ctx, self.state) + self.enterRule(localctx, 364, self.RULE_add_operator_to_family) + self._la = 0 # Token type + try: + self.state = 4285 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.OPERATOR]: + self.enterOuterAlt(localctx, 1) + self.state = 4255 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4256 + self.unsigned_numeric_literal() + self.state = 4257 + self.target_operator() + self.state = 4264 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,482,self._ctx) + if la_ == 1: + self.state = 4258 + self.match(PLpgSQLParser.FOR) + self.state = 4259 + self.match(PLpgSQLParser.SEARCH) + + elif la_ == 2: + self.state = 4260 + self.match(PLpgSQLParser.FOR) + self.state = 4261 + self.match(PLpgSQLParser.ORDER) + self.state = 4262 + self.match(PLpgSQLParser.BY) + self.state = 4263 + self.schema_qualified_name() + + + pass + elif token in [PLpgSQLParser.FUNCTION]: + self.enterOuterAlt(localctx, 2) + self.state = 4266 + self.match(PLpgSQLParser.FUNCTION) + self.state = 4267 + self.unsigned_numeric_literal() + self.state = 4281 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4268 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4271 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,483,self._ctx) + if la_ == 1: + self.state = 4269 + self.data_type() + pass + + elif la_ == 2: + self.state = 4270 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 4278 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 4273 + self.match(PLpgSQLParser.COMMA) + self.state = 4276 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,484,self._ctx) + if la_ == 1: + self.state = 4274 + self.data_type() + pass + + elif la_ == 2: + self.state = 4275 + self.match(PLpgSQLParser.NONE) + pass + + + + + self.state = 4280 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 4283 + self.function_call() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_operator_from_familyContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unsigned_numeric_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_numeric_literalContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def NONE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NONE) + else: + return self.getToken(PLpgSQLParser.NONE, i) + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_operator_from_family + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_operator_from_family" ): + listener.enterDrop_operator_from_family(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_operator_from_family" ): + listener.exitDrop_operator_from_family(self) + + + + + def drop_operator_from_family(self): + + localctx = PLpgSQLParser.Drop_operator_from_familyContext(self, self._ctx, self.state) + self.enterRule(localctx, 366, self.RULE_drop_operator_from_family) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4287 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.OPERATOR): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4288 + self.unsigned_numeric_literal() + self.state = 4289 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4292 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,488,self._ctx) + if la_ == 1: + self.state = 4290 + self.data_type() + pass + + elif la_ == 2: + self.state = 4291 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 4299 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 4294 + self.match(PLpgSQLParser.COMMA) + self.state = 4297 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,489,self._ctx) + if la_ == 1: + self.state = 4295 + self.data_type() + pass + + elif la_ == 2: + self.state = 4296 + self.match(PLpgSQLParser.NONE) + pass + + + + + self.state = 4301 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_operator_family_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_operator_family_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_operator_family_statement" ): + listener.enterDrop_operator_family_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_operator_family_statement" ): + listener.exitDrop_operator_family_statement(self) + + + + + def drop_operator_family_statement(self): + + localctx = PLpgSQLParser.Drop_operator_family_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 368, self.RULE_drop_operator_family_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4303 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4304 + self.match(PLpgSQLParser.FAMILY) + self.state = 4306 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,491,self._ctx) + if la_ == 1: + self.state = 4305 + self.if_exists() + + + self.state = 4308 + self.schema_qualified_name() + self.state = 4309 + self.match(PLpgSQLParser.USING) + self.state = 4310 + self.identifier() + self.state = 4312 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 4311 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_operator_class_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def CLASS(self): + return self.getToken(PLpgSQLParser.CLASS, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def create_operator_class_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Create_operator_class_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Create_operator_class_optionContext,i) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_operator_class_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_operator_class_statement" ): + listener.enterCreate_operator_class_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_operator_class_statement" ): + listener.exitCreate_operator_class_statement(self) + + + + + def create_operator_class_statement(self): + + localctx = PLpgSQLParser.Create_operator_class_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 370, self.RULE_create_operator_class_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4314 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4315 + self.match(PLpgSQLParser.CLASS) + self.state = 4316 + self.schema_qualified_name() + self.state = 4318 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFAULT: + self.state = 4317 + self.match(PLpgSQLParser.DEFAULT) + + + self.state = 4320 + self.match(PLpgSQLParser.FOR) + self.state = 4321 + self.match(PLpgSQLParser.TYPE) + self.state = 4322 + self.data_type() + self.state = 4323 + self.match(PLpgSQLParser.USING) + self.state = 4324 + self.identifier() + self.state = 4327 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FAMILY: + self.state = 4325 + self.match(PLpgSQLParser.FAMILY) + self.state = 4326 + self.schema_qualified_name() + + + self.state = 4329 + self.match(PLpgSQLParser.AS) + self.state = 4330 + self.create_operator_class_option() + self.state = 4335 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4331 + self.match(PLpgSQLParser.COMMA) + self.state = 4332 + self.create_operator_class_option() + self.state = 4337 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_operator_class_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Operator_nameContext + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def unsigned_numeric_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_numeric_literalContext,0) + + + def operator_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Operator_nameContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def ORDER(self): + return self.getToken(PLpgSQLParser.ORDER, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def NONE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NONE) + else: + return self.getToken(PLpgSQLParser.NONE, i) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def STORAGE(self): + return self.getToken(PLpgSQLParser.STORAGE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_operator_class_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_operator_class_option" ): + listener.enterCreate_operator_class_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_operator_class_option" ): + listener.exitCreate_operator_class_option(self) + + + + + def create_operator_class_option(self): + + localctx = PLpgSQLParser.Create_operator_class_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 372, self.RULE_create_operator_class_option) + self._la = 0 # Token type + try: + self.state = 4383 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.OPERATOR]: + self.enterOuterAlt(localctx, 1) + self.state = 4338 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4339 + self.unsigned_numeric_literal() + self.state = 4340 + localctx.name = self.operator_name() + self.state = 4352 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4341 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4344 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,496,self._ctx) + if la_ == 1: + self.state = 4342 + self.data_type() + pass + + elif la_ == 2: + self.state = 4343 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 4346 + self.match(PLpgSQLParser.COMMA) + self.state = 4349 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,497,self._ctx) + if la_ == 1: + self.state = 4347 + self.data_type() + pass + + elif la_ == 2: + self.state = 4348 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 4351 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 4360 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,499,self._ctx) + if la_ == 1: + self.state = 4354 + self.match(PLpgSQLParser.FOR) + self.state = 4355 + self.match(PLpgSQLParser.SEARCH) + + elif la_ == 2: + self.state = 4356 + self.match(PLpgSQLParser.FOR) + self.state = 4357 + self.match(PLpgSQLParser.ORDER) + self.state = 4358 + self.match(PLpgSQLParser.BY) + self.state = 4359 + self.schema_qualified_name() + + + pass + elif token in [PLpgSQLParser.FUNCTION]: + self.enterOuterAlt(localctx, 2) + self.state = 4362 + self.match(PLpgSQLParser.FUNCTION) + self.state = 4363 + self.unsigned_numeric_literal() + self.state = 4377 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4364 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4367 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,500,self._ctx) + if la_ == 1: + self.state = 4365 + self.data_type() + pass + + elif la_ == 2: + self.state = 4366 + self.match(PLpgSQLParser.NONE) + pass + + + self.state = 4374 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 4369 + self.match(PLpgSQLParser.COMMA) + self.state = 4372 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,501,self._ctx) + if la_ == 1: + self.state = 4370 + self.data_type() + pass + + elif la_ == 2: + self.state = 4371 + self.match(PLpgSQLParser.NONE) + pass + + + + + self.state = 4376 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 4379 + self.function_call() + pass + elif token in [PLpgSQLParser.STORAGE]: + self.enterOuterAlt(localctx, 3) + self.state = 4381 + self.match(PLpgSQLParser.STORAGE) + self.state = 4382 + self.data_type() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_operator_class_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def CLASS(self): + return self.getToken(PLpgSQLParser.CLASS, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_operator_class_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_operator_class_statement" ): + listener.enterAlter_operator_class_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_operator_class_statement" ): + listener.exitAlter_operator_class_statement(self) + + + + + def alter_operator_class_statement(self): + + localctx = PLpgSQLParser.Alter_operator_class_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 374, self.RULE_alter_operator_class_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4385 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4386 + self.match(PLpgSQLParser.CLASS) + self.state = 4387 + self.schema_qualified_name() + self.state = 4388 + self.match(PLpgSQLParser.USING) + self.state = 4389 + self.identifier() + self.state = 4393 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 4390 + self.rename_to() + pass + elif token in [PLpgSQLParser.OWNER]: + self.state = 4391 + self.owner_to() + pass + elif token in [PLpgSQLParser.SET]: + self.state = 4392 + self.set_schema() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_operator_class_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def CLASS(self): + return self.getToken(PLpgSQLParser.CLASS, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_operator_class_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_operator_class_statement" ): + listener.enterDrop_operator_class_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_operator_class_statement" ): + listener.exitDrop_operator_class_statement(self) + + + + + def drop_operator_class_statement(self): + + localctx = PLpgSQLParser.Drop_operator_class_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 376, self.RULE_drop_operator_class_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4395 + self.match(PLpgSQLParser.OPERATOR) + self.state = 4396 + self.match(PLpgSQLParser.CLASS) + self.state = 4398 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,506,self._ctx) + if la_ == 1: + self.state = 4397 + self.if_exists() + + + self.state = 4400 + self.schema_qualified_name() + self.state = 4401 + self.match(PLpgSQLParser.USING) + self.state = 4402 + self.identifier() + self.state = 4404 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 4403 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_conversion_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONVERSION(self): + return self.getToken(PLpgSQLParser.CONVERSION, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def Character_String_Literal(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.Character_String_Literal) + else: + return self.getToken(PLpgSQLParser.Character_String_Literal, i) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_conversion_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_conversion_statement" ): + listener.enterCreate_conversion_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_conversion_statement" ): + listener.exitCreate_conversion_statement(self) + + + + + def create_conversion_statement(self): + + localctx = PLpgSQLParser.Create_conversion_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 378, self.RULE_create_conversion_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4407 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFAULT: + self.state = 4406 + self.match(PLpgSQLParser.DEFAULT) + + + self.state = 4409 + self.match(PLpgSQLParser.CONVERSION) + self.state = 4410 + self.schema_qualified_name() + self.state = 4411 + self.match(PLpgSQLParser.FOR) + self.state = 4412 + self.match(PLpgSQLParser.Character_String_Literal) + self.state = 4413 + self.match(PLpgSQLParser.TO) + self.state = 4414 + self.match(PLpgSQLParser.Character_String_Literal) + self.state = 4415 + self.match(PLpgSQLParser.FROM) + self.state = 4416 + self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_conversion_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONVERSION(self): + return self.getToken(PLpgSQLParser.CONVERSION, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def set_schema(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_schemaContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_conversion_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_conversion_statement" ): + listener.enterAlter_conversion_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_conversion_statement" ): + listener.exitAlter_conversion_statement(self) + + + + + def alter_conversion_statement(self): + + localctx = PLpgSQLParser.Alter_conversion_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 380, self.RULE_alter_conversion_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4418 + self.match(PLpgSQLParser.CONVERSION) + self.state = 4419 + self.schema_qualified_name() + self.state = 4423 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 4420 + self.rename_to() + pass + elif token in [PLpgSQLParser.OWNER]: + self.state = 4421 + self.owner_to() + pass + elif token in [PLpgSQLParser.SET]: + self.state = 4422 + self.set_schema() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_publication_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def only_table_multiply(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Only_table_multiplyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Only_table_multiplyContext,i) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def TABLES(self): + return self.getToken(PLpgSQLParser.TABLES, 0) + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_publication_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_publication_statement" ): + listener.enterCreate_publication_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_publication_statement" ): + listener.exitCreate_publication_statement(self) + + + + + def create_publication_statement(self): + + localctx = PLpgSQLParser.Create_publication_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 382, self.RULE_create_publication_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4425 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 4426 + self.identifier() + self.state = 4440 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,511,self._ctx) + if la_ == 1: + self.state = 4427 + self.match(PLpgSQLParser.FOR) + self.state = 4428 + self.match(PLpgSQLParser.TABLE) + self.state = 4429 + self.only_table_multiply() + self.state = 4434 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4430 + self.match(PLpgSQLParser.COMMA) + self.state = 4431 + self.only_table_multiply() + self.state = 4436 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + elif la_ == 2: + self.state = 4437 + self.match(PLpgSQLParser.FOR) + self.state = 4438 + self.match(PLpgSQLParser.ALL) + self.state = 4439 + self.match(PLpgSQLParser.TABLES) + + + self.state = 4443 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4442 + self.with_storage_parameter() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_publication_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def alter_publication_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Alter_publication_actionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_publication_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_publication_statement" ): + listener.enterAlter_publication_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_publication_statement" ): + listener.exitAlter_publication_statement(self) + + + + + def alter_publication_statement(self): + + localctx = PLpgSQLParser.Alter_publication_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 384, self.RULE_alter_publication_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4445 + self.match(PLpgSQLParser.PUBLICATION) + self.state = 4446 + self.identifier() + self.state = 4447 + self.alter_publication_action() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_publication_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def owner_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Owner_toContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def only_table_multiply(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Only_table_multiplyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Only_table_multiplyContext,i) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_publication_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_publication_action" ): + listener.enterAlter_publication_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_publication_action" ): + listener.exitAlter_publication_action(self) + + + + + def alter_publication_action(self): + + localctx = PLpgSQLParser.Alter_publication_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 386, self.RULE_alter_publication_action) + self._la = 0 # Token type + try: + self.state = 4463 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,514,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4449 + self.rename_to() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4450 + self.owner_to() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4451 + self.match(PLpgSQLParser.SET) + self.state = 4452 + self.storage_parameter() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 4453 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ADD or _la==PLpgSQLParser.DROP or _la==PLpgSQLParser.SET): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4454 + self.match(PLpgSQLParser.TABLE) + self.state = 4455 + self.only_table_multiply() + self.state = 4460 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4456 + self.match(PLpgSQLParser.COMMA) + self.state = 4457 + self.only_table_multiply() + self.state = 4462 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Only_table_multiplyContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_only_table_multiply + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOnly_table_multiply" ): + listener.enterOnly_table_multiply(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOnly_table_multiply" ): + listener.exitOnly_table_multiply(self) + + + + + def only_table_multiply(self): + + localctx = PLpgSQLParser.Only_table_multiplyContext(self, self._ctx, self.state) + self.enterRule(localctx, 388, self.RULE_only_table_multiply) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4466 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 4465 + self.match(PLpgSQLParser.ONLY) + + + self.state = 4468 + self.schema_qualified_name() + self.state = 4470 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MULTIPLY: + self.state = 4469 + self.match(PLpgSQLParser.MULTIPLY) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_trigger_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def ON(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ON) + else: + return self.getToken(PLpgSQLParser.ON, i) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def DEPENDS(self): + return self.getToken(PLpgSQLParser.DEPENDS, 0) + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_trigger_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_trigger_statement" ): + listener.enterAlter_trigger_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_trigger_statement" ): + listener.exitAlter_trigger_statement(self) + + + + + def alter_trigger_statement(self): + + localctx = PLpgSQLParser.Alter_trigger_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 390, self.RULE_alter_trigger_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4472 + self.match(PLpgSQLParser.TRIGGER) + self.state = 4473 + self.identifier() + self.state = 4474 + self.match(PLpgSQLParser.ON) + self.state = 4475 + self.schema_qualified_name() + self.state = 4481 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RENAME]: + self.state = 4476 + self.rename_to() + pass + elif token in [PLpgSQLParser.DEPENDS]: + self.state = 4477 + self.match(PLpgSQLParser.DEPENDS) + self.state = 4478 + self.match(PLpgSQLParser.ON) + self.state = 4479 + self.match(PLpgSQLParser.EXTENSION) + self.state = 4480 + self.identifier() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alter_rule_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RULE(self): + return self.getToken(PLpgSQLParser.RULE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def rename_to(self): + return self.getTypedRuleContext(PLpgSQLParser.Rename_toContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alter_rule_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlter_rule_statement" ): + listener.enterAlter_rule_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlter_rule_statement" ): + listener.exitAlter_rule_statement(self) + + + + + def alter_rule_statement(self): + + localctx = PLpgSQLParser.Alter_rule_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 392, self.RULE_alter_rule_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4483 + self.match(PLpgSQLParser.RULE) + self.state = 4484 + self.identifier() + self.state = 4485 + self.match(PLpgSQLParser.ON) + self.state = 4486 + self.schema_qualified_name() + self.state = 4487 + self.rename_to() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Copy_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def copy_to_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Copy_to_statementContext,0) + + + def copy_from_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Copy_from_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_copy_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCopy_statement" ): + listener.enterCopy_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCopy_statement" ): + listener.exitCopy_statement(self) + + + + + def copy_statement(self): + + localctx = PLpgSQLParser.Copy_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 394, self.RULE_copy_statement) + try: + self.state = 4491 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,518,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4489 + self.copy_to_statement() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4490 + self.copy_from_statement() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Copy_from_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COPY(self): + return self.getToken(PLpgSQLParser.COPY, 0) + + def table_cols(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_colsContext,0) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def STDIN(self): + return self.getToken(PLpgSQLParser.STDIN, 0) + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def PROGRAM(self): + return self.getToken(PLpgSQLParser.PROGRAM, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def copy_option_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Copy_option_listContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_copy_from_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCopy_from_statement" ): + listener.enterCopy_from_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCopy_from_statement" ): + listener.exitCopy_from_statement(self) + + + + + def copy_from_statement(self): + + localctx = PLpgSQLParser.Copy_from_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 396, self.RULE_copy_from_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4493 + self.match(PLpgSQLParser.COPY) + self.state = 4494 + self.table_cols() + self.state = 4495 + self.match(PLpgSQLParser.FROM) + self.state = 4501 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.PROGRAM, PLpgSQLParser.Character_String_Literal]: + self.state = 4497 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROGRAM: + self.state = 4496 + self.match(PLpgSQLParser.PROGRAM) + + + self.state = 4499 + self.match(PLpgSQLParser.Character_String_Literal) + pass + elif token in [PLpgSQLParser.STDIN]: + self.state = 4500 + self.match(PLpgSQLParser.STDIN) + pass + else: + raise NoViableAltException(self) + + self.state = 4513 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 47)) & ~0x3f) == 0 and ((1 << (_la - 47)) & ((1 << (PLpgSQLParser.CSV - 47)) | (1 << (PLpgSQLParser.DELIMITER - 47)) | (1 << (PLpgSQLParser.ENCODING - 47)) | (1 << (PLpgSQLParser.ESCAPE - 47)) | (1 << (PLpgSQLParser.FORCE - 47)) | (1 << (PLpgSQLParser.HEADER - 47)))) != 0) or _la==PLpgSQLParser.OIDS or _la==PLpgSQLParser.QUOTE or _la==PLpgSQLParser.TEXT or _la==PLpgSQLParser.BINARY or _la==PLpgSQLParser.FREEZE or ((((_la - 415)) & ~0x3f) == 0 and ((1 << (_la - 415)) & ((1 << (PLpgSQLParser.NULL - 415)) | (1 << (PLpgSQLParser.WITH - 415)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 415)) | (1 << (PLpgSQLParser.FORCE_NULL - 415)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 415)) | (1 << (PLpgSQLParser.FORMAT - 415)))) != 0) or _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4504 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4503 + self.match(PLpgSQLParser.WITH) + + + self.state = 4511 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 4506 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4507 + self.copy_option_list() + self.state = 4508 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.CSV, PLpgSQLParser.DELIMITER, PLpgSQLParser.ENCODING, PLpgSQLParser.ESCAPE, PLpgSQLParser.FORCE, PLpgSQLParser.HEADER, PLpgSQLParser.OIDS, PLpgSQLParser.QUOTE, PLpgSQLParser.TEXT, PLpgSQLParser.BINARY, PLpgSQLParser.FREEZE, PLpgSQLParser.NULL, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT]: + self.state = 4510 + self.copy_option_list() + pass + else: + raise NoViableAltException(self) + + + + self.state = 4517 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 4515 + self.match(PLpgSQLParser.WHERE) + self.state = 4516 + self.vex(0) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Copy_to_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COPY(self): + return self.getToken(PLpgSQLParser.COPY, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def table_cols(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_colsContext,0) + + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def data_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_statementContext,0) + + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def STDOUT(self): + return self.getToken(PLpgSQLParser.STDOUT, 0) + + def PROGRAM(self): + return self.getToken(PLpgSQLParser.PROGRAM, 0) + + def copy_option_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Copy_option_listContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_copy_to_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCopy_to_statement" ): + listener.enterCopy_to_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCopy_to_statement" ): + listener.exitCopy_to_statement(self) + + + + + def copy_to_statement(self): + + localctx = PLpgSQLParser.Copy_to_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 398, self.RULE_copy_to_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4519 + self.match(PLpgSQLParser.COPY) + self.state = 4525 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 4520 + self.table_cols() + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 4521 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4522 + self.data_statement() + self.state = 4523 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + self.state = 4527 + self.match(PLpgSQLParser.TO) + self.state = 4533 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.PROGRAM, PLpgSQLParser.Character_String_Literal]: + self.state = 4529 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROGRAM: + self.state = 4528 + self.match(PLpgSQLParser.PROGRAM) + + + self.state = 4531 + self.match(PLpgSQLParser.Character_String_Literal) + pass + elif token in [PLpgSQLParser.STDOUT]: + self.state = 4532 + self.match(PLpgSQLParser.STDOUT) + pass + else: + raise NoViableAltException(self) + + self.state = 4545 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 47)) & ~0x3f) == 0 and ((1 << (_la - 47)) & ((1 << (PLpgSQLParser.CSV - 47)) | (1 << (PLpgSQLParser.DELIMITER - 47)) | (1 << (PLpgSQLParser.ENCODING - 47)) | (1 << (PLpgSQLParser.ESCAPE - 47)) | (1 << (PLpgSQLParser.FORCE - 47)) | (1 << (PLpgSQLParser.HEADER - 47)))) != 0) or _la==PLpgSQLParser.OIDS or _la==PLpgSQLParser.QUOTE or _la==PLpgSQLParser.TEXT or _la==PLpgSQLParser.BINARY or _la==PLpgSQLParser.FREEZE or ((((_la - 415)) & ~0x3f) == 0 and ((1 << (_la - 415)) & ((1 << (PLpgSQLParser.NULL - 415)) | (1 << (PLpgSQLParser.WITH - 415)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 415)) | (1 << (PLpgSQLParser.FORCE_NULL - 415)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 415)) | (1 << (PLpgSQLParser.FORMAT - 415)))) != 0) or _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4536 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4535 + self.match(PLpgSQLParser.WITH) + + + self.state = 4543 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 4538 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4539 + self.copy_option_list() + self.state = 4540 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.CSV, PLpgSQLParser.DELIMITER, PLpgSQLParser.ENCODING, PLpgSQLParser.ESCAPE, PLpgSQLParser.FORCE, PLpgSQLParser.HEADER, PLpgSQLParser.OIDS, PLpgSQLParser.QUOTE, PLpgSQLParser.TEXT, PLpgSQLParser.BINARY, PLpgSQLParser.FREEZE, PLpgSQLParser.NULL, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT]: + self.state = 4542 + self.copy_option_list() + pass + else: + raise NoViableAltException(self) + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Copy_option_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def copy_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Copy_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Copy_optionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_copy_option_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCopy_option_list" ): + listener.enterCopy_option_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCopy_option_list" ): + listener.exitCopy_option_list(self) + + + + + def copy_option_list(self): + + localctx = PLpgSQLParser.Copy_option_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 400, self.RULE_copy_option_list) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4547 + self.copy_option() + self.state = 4554 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 47)) & ~0x3f) == 0 and ((1 << (_la - 47)) & ((1 << (PLpgSQLParser.CSV - 47)) | (1 << (PLpgSQLParser.DELIMITER - 47)) | (1 << (PLpgSQLParser.ENCODING - 47)) | (1 << (PLpgSQLParser.ESCAPE - 47)) | (1 << (PLpgSQLParser.FORCE - 47)) | (1 << (PLpgSQLParser.HEADER - 47)))) != 0) or _la==PLpgSQLParser.OIDS or _la==PLpgSQLParser.QUOTE or _la==PLpgSQLParser.TEXT or _la==PLpgSQLParser.BINARY or _la==PLpgSQLParser.FREEZE or ((((_la - 415)) & ~0x3f) == 0 and ((1 << (_la - 415)) & ((1 << (PLpgSQLParser.NULL - 415)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 415)) | (1 << (PLpgSQLParser.FORCE_NULL - 415)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 415)) | (1 << (PLpgSQLParser.FORMAT - 415)))) != 0) or _la==PLpgSQLParser.COMMA: + self.state = 4549 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 4548 + self.match(PLpgSQLParser.COMMA) + + + self.state = 4551 + self.copy_option() + self.state = 4556 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Copy_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def CSV(self): + return self.getToken(PLpgSQLParser.CSV, 0) + + def BINARY(self): + return self.getToken(PLpgSQLParser.BINARY, 0) + + def FORMAT(self): + return self.getToken(PLpgSQLParser.FORMAT, 0) + + def OIDS(self): + return self.getToken(PLpgSQLParser.OIDS, 0) + + def truth_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Truth_valueContext,0) + + + def FREEZE(self): + return self.getToken(PLpgSQLParser.FREEZE, 0) + + def DELIMITER(self): + return self.getToken(PLpgSQLParser.DELIMITER, 0) + + def Character_String_Literal(self): + return self.getToken(PLpgSQLParser.Character_String_Literal, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def HEADER(self): + return self.getToken(PLpgSQLParser.HEADER, 0) + + def QUOTE(self): + return self.getToken(PLpgSQLParser.QUOTE, 0) + + def ESCAPE(self): + return self.getToken(PLpgSQLParser.ESCAPE, 0) + + def FORCE(self): + return self.getToken(PLpgSQLParser.FORCE, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def FORCE_QUOTE(self): + return self.getToken(PLpgSQLParser.FORCE_QUOTE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def FORCE_NOT_NULL(self): + return self.getToken(PLpgSQLParser.FORCE_NOT_NULL, 0) + + def FORCE_NULL(self): + return self.getToken(PLpgSQLParser.FORCE_NULL, 0) + + def ENCODING(self): + return self.getToken(PLpgSQLParser.ENCODING, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_copy_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCopy_option" ): + listener.enterCopy_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCopy_option" ): + listener.exitCopy_option(self) + + + + + def copy_option(self): + + localctx = PLpgSQLParser.Copy_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 402, self.RULE_copy_option) + self._la = 0 # Token type + try: + self.state = 4617 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,541,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4558 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FORMAT: + self.state = 4557 + self.match(PLpgSQLParser.FORMAT) + + + self.state = 4560 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CSV or _la==PLpgSQLParser.TEXT or _la==PLpgSQLParser.BINARY): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4561 + self.match(PLpgSQLParser.OIDS) + self.state = 4563 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0): + self.state = 4562 + self.truth_value() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4565 + self.match(PLpgSQLParser.FREEZE) + self.state = 4567 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0): + self.state = 4566 + self.truth_value() + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 4569 + self.match(PLpgSQLParser.DELIMITER) + self.state = 4571 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 4570 + self.match(PLpgSQLParser.AS) + + + self.state = 4573 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 4574 + self.match(PLpgSQLParser.NULL) + self.state = 4576 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 4575 + self.match(PLpgSQLParser.AS) + + + self.state = 4578 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 4579 + self.match(PLpgSQLParser.HEADER) + self.state = 4581 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0): + self.state = 4580 + self.truth_value() + + + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 4583 + self.match(PLpgSQLParser.QUOTE) + self.state = 4584 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 4585 + self.match(PLpgSQLParser.ESCAPE) + self.state = 4586 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 4587 + self.match(PLpgSQLParser.FORCE) + self.state = 4588 + self.match(PLpgSQLParser.QUOTE) + self.state = 4591 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.MULTIPLY]: + self.state = 4589 + self.match(PLpgSQLParser.MULTIPLY) + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 4590 + self.identifier_list() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 4593 + self.match(PLpgSQLParser.FORCE_QUOTE) + self.state = 4599 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.MULTIPLY]: + self.state = 4594 + self.match(PLpgSQLParser.MULTIPLY) + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 4595 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4596 + self.identifier_list() + self.state = 4597 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 4601 + self.match(PLpgSQLParser.FORCE) + self.state = 4602 + self.match(PLpgSQLParser.NOT) + self.state = 4603 + self.match(PLpgSQLParser.NULL) + self.state = 4604 + self.identifier_list() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 4605 + self.match(PLpgSQLParser.FORCE_NOT_NULL) + self.state = 4606 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4607 + self.identifier_list() + self.state = 4608 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 4610 + self.match(PLpgSQLParser.FORCE_NULL) + self.state = 4611 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4612 + self.identifier_list() + self.state = 4613 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 4615 + self.match(PLpgSQLParser.ENCODING) + self.state = 4616 + self.match(PLpgSQLParser.Character_String_Literal) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_view_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + self.column_names = None # View_columnsContext + self.v_query = None # Select_stmtContext + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def RECURSIVE(self): + return self.getToken(PLpgSQLParser.RECURSIVE, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def WITH(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WITH) + else: + return self.getToken(PLpgSQLParser.WITH, i) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def table_space(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_spaceContext,0) + + + def with_check_option(self): + return self.getTypedRuleContext(PLpgSQLParser.With_check_optionContext,0) + + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def view_columns(self): + return self.getTypedRuleContext(PLpgSQLParser.View_columnsContext,0) + + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_view_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_view_statement" ): + listener.enterCreate_view_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_view_statement" ): + listener.exitCreate_view_statement(self) + + + + + def create_view_statement(self): + + localctx = PLpgSQLParser.Create_view_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 404, self.RULE_create_view_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4621 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OR: + self.state = 4619 + self.match(PLpgSQLParser.OR) + self.state = 4620 + self.match(PLpgSQLParser.REPLACE) + + + self.state = 4624 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY: + self.state = 4623 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4627 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.RECURSIVE: + self.state = 4626 + self.match(PLpgSQLParser.RECURSIVE) + + + self.state = 4630 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 4629 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 4632 + self.match(PLpgSQLParser.VIEW) + self.state = 4634 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,546,self._ctx) + if la_ == 1: + self.state = 4633 + self.if_not_exists() + + + self.state = 4636 + localctx.name = self.schema_qualified_name() + self.state = 4638 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4637 + localctx.column_names = self.view_columns() + + + self.state = 4642 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 4640 + self.match(PLpgSQLParser.USING) + self.state = 4641 + self.identifier() + + + self.state = 4646 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4644 + self.match(PLpgSQLParser.WITH) + self.state = 4645 + self.storage_parameter() + + + self.state = 4649 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLESPACE: + self.state = 4648 + self.table_space() + + + self.state = 4651 + self.match(PLpgSQLParser.AS) + self.state = 4652 + localctx.v_query = self.select_stmt() + self.state = 4654 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,551,self._ctx) + if la_ == 1: + self.state = 4653 + self.with_check_option() + + + self.state = 4661 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4656 + self.match(PLpgSQLParser.WITH) + self.state = 4658 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 4657 + self.match(PLpgSQLParser.NO) + + + self.state = 4660 + self.match(PLpgSQLParser.DATA) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class If_existsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def IF(self): + return self.getToken(PLpgSQLParser.IF, 0) + + def EXISTS(self): + return self.getToken(PLpgSQLParser.EXISTS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_if_exists + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIf_exists" ): + listener.enterIf_exists(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIf_exists" ): + listener.exitIf_exists(self) + + + + + def if_exists(self): + + localctx = PLpgSQLParser.If_existsContext(self, self._ctx, self.state) + self.enterRule(localctx, 406, self.RULE_if_exists) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4663 + self.match(PLpgSQLParser.IF) + self.state = 4664 + self.match(PLpgSQLParser.EXISTS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class If_not_existsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def IF(self): + return self.getToken(PLpgSQLParser.IF, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def EXISTS(self): + return self.getToken(PLpgSQLParser.EXISTS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_if_not_exists + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIf_not_exists" ): + listener.enterIf_not_exists(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIf_not_exists" ): + listener.exitIf_not_exists(self) + + + + + def if_not_exists(self): + + localctx = PLpgSQLParser.If_not_existsContext(self, self._ctx, self.state) + self.enterRule(localctx, 408, self.RULE_if_not_exists) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4666 + self.match(PLpgSQLParser.IF) + self.state = 4667 + self.match(PLpgSQLParser.NOT) + self.state = 4668 + self.match(PLpgSQLParser.EXISTS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class View_columnsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_view_columns + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterView_columns" ): + listener.enterView_columns(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitView_columns" ): + listener.exitView_columns(self) + + + + + def view_columns(self): + + localctx = PLpgSQLParser.View_columnsContext(self, self._ctx, self.state) + self.enterRule(localctx, 410, self.RULE_view_columns) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4670 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4671 + self.identifier() + self.state = 4676 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4672 + self.match(PLpgSQLParser.COMMA) + self.state = 4673 + self.identifier() + self.state = 4678 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4679 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class With_check_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def CHECK(self): + return self.getToken(PLpgSQLParser.CHECK, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def CASCADED(self): + return self.getToken(PLpgSQLParser.CASCADED, 0) + + def LOCAL(self): + return self.getToken(PLpgSQLParser.LOCAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_with_check_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWith_check_option" ): + listener.enterWith_check_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWith_check_option" ): + listener.exitWith_check_option(self) + + + + + def with_check_option(self): + + localctx = PLpgSQLParser.With_check_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 412, self.RULE_with_check_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4681 + self.match(PLpgSQLParser.WITH) + self.state = 4683 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADED or _la==PLpgSQLParser.LOCAL: + self.state = 4682 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CASCADED or _la==PLpgSQLParser.LOCAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4685 + self.match(PLpgSQLParser.CHECK) + self.state = 4686 + self.match(PLpgSQLParser.OPTION) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_table_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def define_table(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_tableContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def UNLOGGED(self): + return self.getToken(PLpgSQLParser.UNLOGGED, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def partition_by(self): + return self.getTypedRuleContext(PLpgSQLParser.Partition_byContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def storage_parameter_oid(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameter_oidContext,0) + + + def on_commit(self): + return self.getTypedRuleContext(PLpgSQLParser.On_commitContext,0) + + + def table_space(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_spaceContext,0) + + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def GLOBAL(self): + return self.getToken(PLpgSQLParser.GLOBAL, 0) + + def LOCAL(self): + return self.getToken(PLpgSQLParser.LOCAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_table_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_table_statement" ): + listener.enterCreate_table_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_table_statement" ): + listener.exitCreate_table_statement(self) + + + + + def create_table_statement(self): + + localctx = PLpgSQLParser.Create_table_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 414, self.RULE_create_table_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4693 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.GLOBAL, PLpgSQLParser.LOCAL, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPORARY]: + self.state = 4689 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GLOBAL or _la==PLpgSQLParser.LOCAL: + self.state = 4688 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.GLOBAL or _la==PLpgSQLParser.LOCAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4691 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.UNLOGGED]: + self.state = 4692 + self.match(PLpgSQLParser.UNLOGGED) + pass + elif token in [PLpgSQLParser.TABLE]: + pass + else: + pass + self.state = 4695 + self.match(PLpgSQLParser.TABLE) + self.state = 4697 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,558,self._ctx) + if la_ == 1: + self.state = 4696 + self.if_not_exists() + + + self.state = 4699 + localctx.name = self.schema_qualified_name() + self.state = 4700 + self.define_table() + self.state = 4702 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PARTITION: + self.state = 4701 + self.partition_by() + + + self.state = 4706 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 4704 + self.match(PLpgSQLParser.USING) + self.state = 4705 + self.identifier() + + + self.state = 4709 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITHOUT or _la==PLpgSQLParser.WITH: + self.state = 4708 + self.storage_parameter_oid() + + + self.state = 4712 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ON: + self.state = 4711 + self.on_commit() + + + self.state = 4715 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLESPACE: + self.state = 4714 + self.table_space() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_table_as_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def UNLOGGED(self): + return self.getToken(PLpgSQLParser.UNLOGGED, 0) + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def names_in_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def storage_parameter_oid(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameter_oidContext,0) + + + def on_commit(self): + return self.getTypedRuleContext(PLpgSQLParser.On_commitContext,0) + + + def table_space(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_spaceContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def GLOBAL(self): + return self.getToken(PLpgSQLParser.GLOBAL, 0) + + def LOCAL(self): + return self.getToken(PLpgSQLParser.LOCAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_table_as_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_table_as_statement" ): + listener.enterCreate_table_as_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_table_as_statement" ): + listener.exitCreate_table_as_statement(self) + + + + + def create_table_as_statement(self): + + localctx = PLpgSQLParser.Create_table_as_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 416, self.RULE_create_table_as_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4722 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.GLOBAL, PLpgSQLParser.LOCAL, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPORARY]: + self.state = 4718 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GLOBAL or _la==PLpgSQLParser.LOCAL: + self.state = 4717 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.GLOBAL or _la==PLpgSQLParser.LOCAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4720 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TEMP or _la==PLpgSQLParser.TEMPORARY): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.UNLOGGED]: + self.state = 4721 + self.match(PLpgSQLParser.UNLOGGED) + pass + elif token in [PLpgSQLParser.TABLE]: + pass + else: + pass + self.state = 4724 + self.match(PLpgSQLParser.TABLE) + self.state = 4726 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,566,self._ctx) + if la_ == 1: + self.state = 4725 + self.if_not_exists() + + + self.state = 4728 + localctx.name = self.schema_qualified_name() + self.state = 4730 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4729 + self.names_in_parens() + + + self.state = 4734 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 4732 + self.match(PLpgSQLParser.USING) + self.state = 4733 + self.identifier() + + + self.state = 4737 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITHOUT or _la==PLpgSQLParser.WITH: + self.state = 4736 + self.storage_parameter_oid() + + + self.state = 4740 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ON: + self.state = 4739 + self.on_commit() + + + self.state = 4743 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLESPACE: + self.state = 4742 + self.table_space() + + + self.state = 4745 + self.match(PLpgSQLParser.AS) + self.state = 4749 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE, PLpgSQLParser.WITH, PLpgSQLParser.LEFT_PAREN]: + self.state = 4746 + self.select_stmt() + pass + elif token in [PLpgSQLParser.EXECUTE]: + self.state = 4747 + self.match(PLpgSQLParser.EXECUTE) + self.state = 4748 + self.function_call() + pass + else: + raise NoViableAltException(self) + + self.state = 4756 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4751 + self.match(PLpgSQLParser.WITH) + self.state = 4753 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 4752 + self.match(PLpgSQLParser.NO) + + + self.state = 4755 + self.match(PLpgSQLParser.DATA) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Create_foreign_table_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def define_server(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_serverContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def define_columns(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_columnsContext,0) + + + def define_partition(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_partitionContext,0) + + + def if_not_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_not_existsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_create_foreign_table_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCreate_foreign_table_statement" ): + listener.enterCreate_foreign_table_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCreate_foreign_table_statement" ): + listener.exitCreate_foreign_table_statement(self) + + + + + def create_foreign_table_statement(self): + + localctx = PLpgSQLParser.Create_foreign_table_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 418, self.RULE_create_foreign_table_statement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4758 + self.match(PLpgSQLParser.FOREIGN) + self.state = 4759 + self.match(PLpgSQLParser.TABLE) + self.state = 4761 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,575,self._ctx) + if la_ == 1: + self.state = 4760 + self.if_not_exists() + + + self.state = 4763 + localctx.name = self.schema_qualified_name() + self.state = 4766 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 4764 + self.define_columns() + pass + elif token in [PLpgSQLParser.PARTITION]: + self.state = 4765 + self.define_partition() + pass + else: + raise NoViableAltException(self) + + self.state = 4768 + self.define_server() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Define_tableContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def define_columns(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_columnsContext,0) + + + def define_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_typeContext,0) + + + def define_partition(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_partitionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_define_table + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefine_table" ): + listener.enterDefine_table(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefine_table" ): + listener.exitDefine_table(self) + + + + + def define_table(self): + + localctx = PLpgSQLParser.Define_tableContext(self, self._ctx, self.state) + self.enterRule(localctx, 420, self.RULE_define_table) + try: + self.state = 4773 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 1) + self.state = 4770 + self.define_columns() + pass + elif token in [PLpgSQLParser.OF]: + self.enterOuterAlt(localctx, 2) + self.state = 4771 + self.define_type() + pass + elif token in [PLpgSQLParser.PARTITION]: + self.enterOuterAlt(localctx, 3) + self.state = 4772 + self.define_partition() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Define_partitionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.parent_table = None # Schema_qualified_nameContext + + def PARTITION(self): + return self.getToken(PLpgSQLParser.PARTITION, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def for_values_bound(self): + return self.getTypedRuleContext(PLpgSQLParser.For_values_boundContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def list_of_type_column_def(self): + return self.getTypedRuleContext(PLpgSQLParser.List_of_type_column_defContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_define_partition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefine_partition" ): + listener.enterDefine_partition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefine_partition" ): + listener.exitDefine_partition(self) + + + + + def define_partition(self): + + localctx = PLpgSQLParser.Define_partitionContext(self, self._ctx, self.state) + self.enterRule(localctx, 422, self.RULE_define_partition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4775 + self.match(PLpgSQLParser.PARTITION) + self.state = 4776 + self.match(PLpgSQLParser.OF) + self.state = 4777 + localctx.parent_table = self.schema_qualified_name() + self.state = 4779 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4778 + self.list_of_type_column_def() + + + self.state = 4781 + self.for_values_bound() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class For_values_boundContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def VALUES(self): + return self.getToken(PLpgSQLParser.VALUES, 0) + + def partition_bound_spec(self): + return self.getTypedRuleContext(PLpgSQLParser.Partition_bound_specContext,0) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_for_values_bound + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFor_values_bound" ): + listener.enterFor_values_bound(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFor_values_bound" ): + listener.exitFor_values_bound(self) + + + + + def for_values_bound(self): + + localctx = PLpgSQLParser.For_values_boundContext(self, self._ctx, self.state) + self.enterRule(localctx, 424, self.RULE_for_values_bound) + try: + self.state = 4787 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.FOR]: + self.enterOuterAlt(localctx, 1) + self.state = 4783 + self.match(PLpgSQLParser.FOR) + self.state = 4784 + self.match(PLpgSQLParser.VALUES) + self.state = 4785 + self.partition_bound_spec() + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.enterOuterAlt(localctx, 2) + self.state = 4786 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Partition_bound_specContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def partition_bound_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Partition_bound_partContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Partition_bound_partContext,i) + + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def MODULUS(self): + return self.getToken(PLpgSQLParser.MODULUS, 0) + + def NUMBER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NUMBER_LITERAL) + else: + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, i) + + def REMAINDER(self): + return self.getToken(PLpgSQLParser.REMAINDER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_partition_bound_spec + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartition_bound_spec" ): + listener.enterPartition_bound_spec(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartition_bound_spec" ): + listener.exitPartition_bound_spec(self) + + + + + def partition_bound_spec(self): + + localctx = PLpgSQLParser.Partition_bound_specContext(self, self._ctx, self.state) + self.enterRule(localctx, 426, self.RULE_partition_bound_spec) + self._la = 0 # Token type + try: + self.state = 4814 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.IN]: + self.enterOuterAlt(localctx, 1) + self.state = 4789 + self.match(PLpgSQLParser.IN) + self.state = 4790 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4791 + self.vex(0) + self.state = 4796 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4792 + self.match(PLpgSQLParser.COMMA) + self.state = 4793 + self.vex(0) + self.state = 4798 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4799 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.FROM]: + self.enterOuterAlt(localctx, 2) + self.state = 4801 + self.match(PLpgSQLParser.FROM) + self.state = 4802 + self.partition_bound_part() + self.state = 4803 + self.match(PLpgSQLParser.TO) + self.state = 4804 + self.partition_bound_part() + pass + elif token in [PLpgSQLParser.WITH]: + self.enterOuterAlt(localctx, 3) + self.state = 4806 + self.match(PLpgSQLParser.WITH) + self.state = 4807 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4808 + self.match(PLpgSQLParser.MODULUS) + self.state = 4809 + self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 4810 + self.match(PLpgSQLParser.COMMA) + self.state = 4811 + self.match(PLpgSQLParser.REMAINDER) + self.state = 4812 + self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 4813 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Partition_bound_partContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_partition_bound_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartition_bound_part" ): + listener.enterPartition_bound_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartition_bound_part" ): + listener.exitPartition_bound_part(self) + + + + + def partition_bound_part(self): + + localctx = PLpgSQLParser.Partition_bound_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 428, self.RULE_partition_bound_part) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4816 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4817 + self.vex(0) + self.state = 4822 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4818 + self.match(PLpgSQLParser.COMMA) + self.state = 4819 + self.vex(0) + self.state = 4824 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4825 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Define_columnsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def table_column_def(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_column_defContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_column_defContext,i) + + + def INHERITS(self): + return self.getToken(PLpgSQLParser.INHERITS, 0) + + def names_in_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_define_columns + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefine_columns" ): + listener.enterDefine_columns(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefine_columns" ): + listener.exitDefine_columns(self) + + + + + def define_columns(self): + + localctx = PLpgSQLParser.Define_columnsContext(self, self._ctx, self.state) + self.enterRule(localctx, 430, self.RULE_define_columns) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4827 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4836 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.CHECK - 320)) | (1 << (PLpgSQLParser.CONSTRAINT - 320)))) != 0) or ((((_la - 389)) & ~0x3f) == 0 and ((1 << (_la - 389)) & ((1 << (PLpgSQLParser.DEFAULT - 389)) | (1 << (PLpgSQLParser.FOREIGN - 389)) | (1 << (PLpgSQLParser.NOT - 389)) | (1 << (PLpgSQLParser.NULL - 389)) | (1 << (PLpgSQLParser.PRIMARY - 389)) | (1 << (PLpgSQLParser.REFERENCES - 389)) | (1 << (PLpgSQLParser.UNIQUE - 389)) | (1 << (PLpgSQLParser.ALIGNMENT - 389)) | (1 << (PLpgSQLParser.BASETYPE - 389)) | (1 << (PLpgSQLParser.BUFFERS - 389)) | (1 << (PLpgSQLParser.BYPASSRLS - 389)) | (1 << (PLpgSQLParser.CANONICAL - 389)) | (1 << (PLpgSQLParser.CATEGORY - 389)) | (1 << (PLpgSQLParser.COLLATABLE - 389)) | (1 << (PLpgSQLParser.COMBINEFUNC - 389)) | (1 << (PLpgSQLParser.COMMUTATOR - 389)) | (1 << (PLpgSQLParser.CONNECT - 389)))) != 0) or ((((_la - 453)) & ~0x3f) == 0 and ((1 << (_la - 453)) & ((1 << (PLpgSQLParser.COSTS - 453)) | (1 << (PLpgSQLParser.CREATEDB - 453)) | (1 << (PLpgSQLParser.CREATEROLE - 453)) | (1 << (PLpgSQLParser.DESERIALFUNC - 453)) | (1 << (PLpgSQLParser.DETERMINISTIC - 453)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 453)) | (1 << (PLpgSQLParser.ELEMENT - 453)) | (1 << (PLpgSQLParser.EXTENDED - 453)) | (1 << (PLpgSQLParser.FINALFUNC - 453)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 453)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 453)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 453)) | (1 << (PLpgSQLParser.FORCE_NULL - 453)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 453)) | (1 << (PLpgSQLParser.FORMAT - 453)) | (1 << (PLpgSQLParser.GETTOKEN - 453)) | (1 << (PLpgSQLParser.HASH - 453)) | (1 << (PLpgSQLParser.HASHES - 453)) | (1 << (PLpgSQLParser.HEADLINE - 453)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 453)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 453)) | (1 << (PLpgSQLParser.INIT - 453)) | (1 << (PLpgSQLParser.INITCOND - 453)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 453)) | (1 << (PLpgSQLParser.JSON - 453)) | (1 << (PLpgSQLParser.LC_COLLATE - 453)) | (1 << (PLpgSQLParser.LC_CTYPE - 453)) | (1 << (PLpgSQLParser.LEFTARG - 453)) | (1 << (PLpgSQLParser.LEXIZE - 453)) | (1 << (PLpgSQLParser.LEXTYPES - 453)) | (1 << (PLpgSQLParser.LIST - 453)) | (1 << (PLpgSQLParser.LOCALE - 453)) | (1 << (PLpgSQLParser.LOGIN - 453)) | (1 << (PLpgSQLParser.MAIN - 453)) | (1 << (PLpgSQLParser.MERGES - 453)) | (1 << (PLpgSQLParser.MFINALFUNC - 453)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 453)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 453)) | (1 << (PLpgSQLParser.MINITCOND - 453)) | (1 << (PLpgSQLParser.MINVFUNC - 453)) | (1 << (PLpgSQLParser.MODULUS - 453)) | (1 << (PLpgSQLParser.MSFUNC - 453)) | (1 << (PLpgSQLParser.MSSPACE - 453)) | (1 << (PLpgSQLParser.MSTYPE - 453)) | (1 << (PLpgSQLParser.NEGATOR - 453)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 453)) | (1 << (PLpgSQLParser.NOCREATEDB - 453)) | (1 << (PLpgSQLParser.NOCREATEROLE - 453)) | (1 << (PLpgSQLParser.NOINHERIT - 453)) | (1 << (PLpgSQLParser.NOLOGIN - 453)) | (1 << (PLpgSQLParser.NOREPLICATION - 453)) | (1 << (PLpgSQLParser.NOSUPERUSER - 453)) | (1 << (PLpgSQLParser.OUTPUT - 453)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 453)) | (1 << (PLpgSQLParser.PATH - 453)) | (1 << (PLpgSQLParser.PERMISSIVE - 453)) | (1 << (PLpgSQLParser.PLAIN - 453)) | (1 << (PLpgSQLParser.PREFERRED - 453)) | (1 << (PLpgSQLParser.PROVIDER - 453)) | (1 << (PLpgSQLParser.READ_ONLY - 453)) | (1 << (PLpgSQLParser.READ_WRITE - 453)) | (1 << (PLpgSQLParser.RECEIVE - 453)) | (1 << (PLpgSQLParser.REMAINDER - 453)) | (1 << (PLpgSQLParser.REPLICATION - 453)))) != 0) or ((((_la - 517)) & ~0x3f) == 0 and ((1 << (_la - 517)) & ((1 << (PLpgSQLParser.RESTRICTED - 517)) | (1 << (PLpgSQLParser.RESTRICTIVE - 517)) | (1 << (PLpgSQLParser.RIGHTARG - 517)) | (1 << (PLpgSQLParser.SAFE - 517)) | (1 << (PLpgSQLParser.SEND - 517)) | (1 << (PLpgSQLParser.SERIALFUNC - 517)) | (1 << (PLpgSQLParser.SETTINGS - 517)) | (1 << (PLpgSQLParser.SFUNC - 517)) | (1 << (PLpgSQLParser.SHAREABLE - 517)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 517)) | (1 << (PLpgSQLParser.SORTOP - 517)) | (1 << (PLpgSQLParser.SSPACE - 517)) | (1 << (PLpgSQLParser.STYPE - 517)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 517)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 517)) | (1 << (PLpgSQLParser.SUBTYPE - 517)) | (1 << (PLpgSQLParser.SUMMARY - 517)) | (1 << (PLpgSQLParser.SUPERUSER - 517)) | (1 << (PLpgSQLParser.TIMING - 517)) | (1 << (PLpgSQLParser.TYPMOD_IN - 517)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 517)) | (1 << (PLpgSQLParser.UNSAFE - 517)) | (1 << (PLpgSQLParser.USAGE - 517)) | (1 << (PLpgSQLParser.VARIABLE - 517)) | (1 << (PLpgSQLParser.YAML - 517)) | (1 << (PLpgSQLParser.ALIAS - 517)) | (1 << (PLpgSQLParser.ASSERT - 517)) | (1 << (PLpgSQLParser.CONSTANT - 517)) | (1 << (PLpgSQLParser.DATATYPE - 517)) | (1 << (PLpgSQLParser.DEBUG - 517)) | (1 << (PLpgSQLParser.DETAIL - 517)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 517)) | (1 << (PLpgSQLParser.ELSEIF - 517)) | (1 << (PLpgSQLParser.ELSIF - 517)) | (1 << (PLpgSQLParser.ERRCODE - 517)) | (1 << (PLpgSQLParser.EXIT - 517)) | (1 << (PLpgSQLParser.EXCEPTION - 517)) | (1 << (PLpgSQLParser.FOREACH - 517)) | (1 << (PLpgSQLParser.GET - 517)) | (1 << (PLpgSQLParser.HINT - 517)) | (1 << (PLpgSQLParser.INFO - 517)) | (1 << (PLpgSQLParser.LOG - 517)) | (1 << (PLpgSQLParser.LOOP - 517)) | (1 << (PLpgSQLParser.MESSAGE - 517)) | (1 << (PLpgSQLParser.NOTICE - 517)) | (1 << (PLpgSQLParser.OPEN - 517)) | (1 << (PLpgSQLParser.PERFORM - 517)) | (1 << (PLpgSQLParser.QUERY - 517)) | (1 << (PLpgSQLParser.RAISE - 517)) | (1 << (PLpgSQLParser.RECORD - 517)) | (1 << (PLpgSQLParser.RETURN - 517)) | (1 << (PLpgSQLParser.REVERSE - 517)) | (1 << (PLpgSQLParser.ROWTYPE - 517)) | (1 << (PLpgSQLParser.SLICE - 517)) | (1 << (PLpgSQLParser.SQLSTATE - 517)) | (1 << (PLpgSQLParser.STACKED - 517)) | (1 << (PLpgSQLParser.WARNING - 517)) | (1 << (PLpgSQLParser.WHILE - 517)))) != 0) or _la==PLpgSQLParser.Identifier or _la==PLpgSQLParser.QuotedIdentifier: + self.state = 4828 + self.table_column_def() + self.state = 4833 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4829 + self.match(PLpgSQLParser.COMMA) + self.state = 4830 + self.table_column_def() + self.state = 4835 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 4838 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 4841 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INHERITS: + self.state = 4839 + self.match(PLpgSQLParser.INHERITS) + self.state = 4840 + self.names_in_parens() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Define_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.type_name = None # Data_typeContext + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def list_of_type_column_def(self): + return self.getTypedRuleContext(PLpgSQLParser.List_of_type_column_defContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_define_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefine_type" ): + listener.enterDefine_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefine_type" ): + listener.exitDefine_type(self) + + + + + def define_type(self): + + localctx = PLpgSQLParser.Define_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 432, self.RULE_define_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4843 + self.match(PLpgSQLParser.OF) + self.state = 4844 + localctx.type_name = self.data_type() + self.state = 4846 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4845 + self.list_of_type_column_def() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Partition_byContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PARTITION(self): + return self.getToken(PLpgSQLParser.PARTITION, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def partition_method(self): + return self.getTypedRuleContext(PLpgSQLParser.Partition_methodContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_partition_by + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartition_by" ): + listener.enterPartition_by(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartition_by" ): + listener.exitPartition_by(self) + + + + + def partition_by(self): + + localctx = PLpgSQLParser.Partition_byContext(self, self._ctx, self.state) + self.enterRule(localctx, 434, self.RULE_partition_by) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4848 + self.match(PLpgSQLParser.PARTITION) + self.state = 4849 + self.match(PLpgSQLParser.BY) + self.state = 4850 + self.partition_method() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Partition_methodContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def partition_column(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Partition_columnContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Partition_columnContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def RANGE(self): + return self.getToken(PLpgSQLParser.RANGE, 0) + + def LIST(self): + return self.getToken(PLpgSQLParser.LIST, 0) + + def HASH(self): + return self.getToken(PLpgSQLParser.HASH, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_partition_method + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartition_method" ): + listener.enterPartition_method(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartition_method" ): + listener.exitPartition_method(self) + + + + + def partition_method(self): + + localctx = PLpgSQLParser.Partition_methodContext(self, self._ctx, self.state) + self.enterRule(localctx, 436, self.RULE_partition_method) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4852 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.RANGE or _la==PLpgSQLParser.HASH or _la==PLpgSQLParser.LIST): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4853 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4854 + self.partition_column() + self.state = 4859 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4855 + self.match(PLpgSQLParser.COMMA) + self.state = 4856 + self.partition_column() + self.state = 4861 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4862 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Partition_columnContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_partition_column + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartition_column" ): + listener.enterPartition_column(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartition_column" ): + listener.exitPartition_column(self) + + + + + def partition_column(self): + + localctx = PLpgSQLParser.Partition_columnContext(self, self._ctx, self.state) + self.enterRule(localctx, 438, self.RULE_partition_column) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4864 + self.vex(0) + self.state = 4866 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 4865 + self.identifier() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Define_serverContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_define_server + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefine_server" ): + listener.enterDefine_server(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefine_server" ): + listener.exitDefine_server(self) + + + + + def define_server(self): + + localctx = PLpgSQLParser.Define_serverContext(self, self._ctx, self.state) + self.enterRule(localctx, 440, self.RULE_define_server) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4868 + self.match(PLpgSQLParser.SERVER) + self.state = 4869 + self.identifier() + self.state = 4871 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 4870 + self.define_foreign_options() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Define_foreign_optionsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPTIONS(self): + return self.getToken(PLpgSQLParser.OPTIONS, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def foreign_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Foreign_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Foreign_optionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_define_foreign_options + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefine_foreign_options" ): + listener.enterDefine_foreign_options(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefine_foreign_options" ): + listener.exitDefine_foreign_options(self) + + + + + def define_foreign_options(self): + + localctx = PLpgSQLParser.Define_foreign_optionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 442, self.RULE_define_foreign_options) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4873 + self.match(PLpgSQLParser.OPTIONS) + self.state = 4874 + self.match(PLpgSQLParser.LEFT_PAREN) + + self.state = 4875 + self.foreign_option() + self.state = 4880 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4876 + self.match(PLpgSQLParser.COMMA) + self.state = 4877 + self.foreign_option() + self.state = 4882 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4883 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Foreign_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def foreign_option_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Foreign_option_nameContext,0) + + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_foreign_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterForeign_option" ): + listener.enterForeign_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitForeign_option" ): + listener.exitForeign_option(self) + + + + + def foreign_option(self): + + localctx = PLpgSQLParser.Foreign_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 444, self.RULE_foreign_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4886 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,591,self._ctx) + if la_ == 1: + self.state = 4885 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ADD or _la==PLpgSQLParser.DROP or _la==PLpgSQLParser.SET): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 4888 + self.foreign_option_name() + self.state = 4890 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.Character_String_Literal or _la==PLpgSQLParser.BeginDollarStringConstant: + self.state = 4889 + self.character_string() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Foreign_option_nameContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_foreign_option_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterForeign_option_name" ): + listener.enterForeign_option_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitForeign_option_name" ): + listener.exitForeign_option_name(self) + + + + + def foreign_option_name(self): + + localctx = PLpgSQLParser.Foreign_option_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 446, self.RULE_foreign_option_name) + try: + self.state = 4894 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 1) + self.state = 4892 + self.identifier() + pass + elif token in [PLpgSQLParser.USER]: + self.enterOuterAlt(localctx, 2) + self.state = 4893 + self.match(PLpgSQLParser.USER) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class List_of_type_column_defContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def table_of_type_column_def(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Table_of_type_column_defContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Table_of_type_column_defContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_list_of_type_column_def + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterList_of_type_column_def" ): + listener.enterList_of_type_column_def(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitList_of_type_column_def" ): + listener.exitList_of_type_column_def(self) + + + + + def list_of_type_column_def(self): + + localctx = PLpgSQLParser.List_of_type_column_defContext(self, self._ctx, self.state) + self.enterRule(localctx, 448, self.RULE_list_of_type_column_def) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4896 + self.match(PLpgSQLParser.LEFT_PAREN) + + self.state = 4897 + self.table_of_type_column_def() + self.state = 4902 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4898 + self.match(PLpgSQLParser.COMMA) + self.state = 4899 + self.table_of_type_column_def() + self.state = 4904 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4905 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_column_defContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.tabl_constraint = None # Constraint_commonContext + + def table_column_definition(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_column_definitionContext,0) + + + def constraint_common(self): + return self.getTypedRuleContext(PLpgSQLParser.Constraint_commonContext,0) + + + def LIKE(self): + return self.getToken(PLpgSQLParser.LIKE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def like_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Like_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Like_optionContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_column_def + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_column_def" ): + listener.enterTable_column_def(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_column_def" ): + listener.exitTable_column_def(self) + + + + + def table_column_def(self): + + localctx = PLpgSQLParser.Table_column_defContext(self, self._ctx, self.state) + self.enterRule(localctx, 450, self.RULE_table_column_def) + self._la = 0 # Token type + try: + self.state = 4917 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,596,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4907 + self.table_column_definition() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4908 + localctx.tabl_constraint = self.constraint_common() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4909 + self.match(PLpgSQLParser.LIKE) + self.state = 4910 + self.schema_qualified_name() + self.state = 4914 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.EXCLUDING or _la==PLpgSQLParser.INCLUDING: + self.state = 4911 + self.like_option() + self.state = 4916 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_of_type_column_defContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.tabl_constraint = None # Constraint_commonContext + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def OPTIONS(self): + return self.getToken(PLpgSQLParser.OPTIONS, 0) + + def constraint_common(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Constraint_commonContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Constraint_commonContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_of_type_column_def + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_of_type_column_def" ): + listener.enterTable_of_type_column_def(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_of_type_column_def" ): + listener.exitTable_of_type_column_def(self) + + + + + def table_of_type_column_def(self): + + localctx = PLpgSQLParser.Table_of_type_column_defContext(self, self._ctx, self.state) + self.enterRule(localctx, 452, self.RULE_table_of_type_column_def) + self._la = 0 # Token type + try: + self.state = 4931 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,599,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4919 + self.identifier() + self.state = 4922 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 4920 + self.match(PLpgSQLParser.WITH) + self.state = 4921 + self.match(PLpgSQLParser.OPTIONS) + + + self.state = 4927 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.EXCLUDE or _la==PLpgSQLParser.GENERATED or ((((_la - 378)) & ~0x3f) == 0 and ((1 << (_la - 378)) & ((1 << (PLpgSQLParser.CHECK - 378)) | (1 << (PLpgSQLParser.CONSTRAINT - 378)) | (1 << (PLpgSQLParser.DEFAULT - 378)) | (1 << (PLpgSQLParser.FOREIGN - 378)) | (1 << (PLpgSQLParser.NOT - 378)) | (1 << (PLpgSQLParser.NULL - 378)) | (1 << (PLpgSQLParser.PRIMARY - 378)) | (1 << (PLpgSQLParser.REFERENCES - 378)) | (1 << (PLpgSQLParser.UNIQUE - 378)))) != 0): + self.state = 4924 + self.constraint_common() + self.state = 4929 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4930 + localctx.tabl_constraint = self.constraint_common() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_column_definitionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def define_foreign_options(self): + return self.getTypedRuleContext(PLpgSQLParser.Define_foreign_optionsContext,0) + + + def collate_identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Collate_identifierContext,0) + + + def constraint_common(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Constraint_commonContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Constraint_commonContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_column_definition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_column_definition" ): + listener.enterTable_column_definition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_column_definition" ): + listener.exitTable_column_definition(self) + + + + + def table_column_definition(self): + + localctx = PLpgSQLParser.Table_column_definitionContext(self, self._ctx, self.state) + self.enterRule(localctx, 454, self.RULE_table_column_definition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4933 + self.identifier() + self.state = 4934 + self.data_type() + self.state = 4936 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OPTIONS: + self.state = 4935 + self.define_foreign_options() + + + self.state = 4939 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLLATE: + self.state = 4938 + self.collate_identifier() + + + self.state = 4944 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.EXCLUDE or _la==PLpgSQLParser.GENERATED or ((((_la - 378)) & ~0x3f) == 0 and ((1 << (_la - 378)) & ((1 << (PLpgSQLParser.CHECK - 378)) | (1 << (PLpgSQLParser.CONSTRAINT - 378)) | (1 << (PLpgSQLParser.DEFAULT - 378)) | (1 << (PLpgSQLParser.FOREIGN - 378)) | (1 << (PLpgSQLParser.NOT - 378)) | (1 << (PLpgSQLParser.NULL - 378)) | (1 << (PLpgSQLParser.PRIMARY - 378)) | (1 << (PLpgSQLParser.REFERENCES - 378)) | (1 << (PLpgSQLParser.UNIQUE - 378)))) != 0): + self.state = 4941 + self.constraint_common() + self.state = 4946 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Like_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INCLUDING(self): + return self.getToken(PLpgSQLParser.INCLUDING, 0) + + def EXCLUDING(self): + return self.getToken(PLpgSQLParser.EXCLUDING, 0) + + def COMMENTS(self): + return self.getToken(PLpgSQLParser.COMMENTS, 0) + + def CONSTRAINTS(self): + return self.getToken(PLpgSQLParser.CONSTRAINTS, 0) + + def DEFAULTS(self): + return self.getToken(PLpgSQLParser.DEFAULTS, 0) + + def GENERATED(self): + return self.getToken(PLpgSQLParser.GENERATED, 0) + + def IDENTITY(self): + return self.getToken(PLpgSQLParser.IDENTITY, 0) + + def INDEXES(self): + return self.getToken(PLpgSQLParser.INDEXES, 0) + + def STORAGE(self): + return self.getToken(PLpgSQLParser.STORAGE, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_like_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLike_option" ): + listener.enterLike_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLike_option" ): + listener.exitLike_option(self) + + + + + def like_option(self): + + localctx = PLpgSQLParser.Like_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 456, self.RULE_like_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4947 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.EXCLUDING or _la==PLpgSQLParser.INCLUDING): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4948 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.DEFAULTS))) != 0) or ((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & ((1 << (PLpgSQLParser.GENERATED - 94)) | (1 << (PLpgSQLParser.IDENTITY - 94)) | (1 << (PLpgSQLParser.INDEXES - 94)))) != 0) or _la==PLpgSQLParser.STORAGE or _la==PLpgSQLParser.ALL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Constraint_commonContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def constr_body(self): + return self.getTypedRuleContext(PLpgSQLParser.Constr_bodyContext,0) + + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def table_deferrable(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_deferrableContext,0) + + + def table_initialy_immed(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_initialy_immedContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_constraint_common + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConstraint_common" ): + listener.enterConstraint_common(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConstraint_common" ): + listener.exitConstraint_common(self) + + + + + def constraint_common(self): + + localctx = PLpgSQLParser.Constraint_commonContext(self, self._ctx, self.state) + self.enterRule(localctx, 458, self.RULE_constraint_common) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4952 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONSTRAINT: + self.state = 4950 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 4951 + self.identifier() + + + self.state = 4954 + self.constr_body() + self.state = 4956 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,604,self._ctx) + if la_ == 1: + self.state = 4955 + self.table_deferrable() + + + self.state = 4959 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INITIALLY: + self.state = 4958 + self.table_initialy_immed() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Constr_bodyContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.index_method = None # IdentifierContext + self.where = None # Token + self.exp = None # VexContext + self.ref = None # Names_in_parensContext + self.expression = None # VexContext + self.col = None # Names_in_parensContext + self.default_expr = None # VexContext + + def EXCLUDE(self): + return self.getToken(PLpgSQLParser.EXCLUDE, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def sort_specifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Sort_specifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Sort_specifierContext,i) + + + def WITH(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WITH) + else: + return self.getToken(PLpgSQLParser.WITH, i) + + def all_op(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.All_opContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.All_opContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def index_parameters(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_parametersContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def REFERENCES(self): + return self.getToken(PLpgSQLParser.REFERENCES, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def KEY(self): + return self.getToken(PLpgSQLParser.KEY, 0) + + def names_in_parens(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Names_in_parensContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,i) + + + def MATCH(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.MATCH) + else: + return self.getToken(PLpgSQLParser.MATCH, i) + + def ON(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ON) + else: + return self.getToken(PLpgSQLParser.ON, i) + + def action(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.ActionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.ActionContext,i) + + + def FULL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.FULL) + else: + return self.getToken(PLpgSQLParser.FULL, i) + + def PARTIAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.PARTIAL) + else: + return self.getToken(PLpgSQLParser.PARTIAL, i) + + def SIMPLE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SIMPLE) + else: + return self.getToken(PLpgSQLParser.SIMPLE, i) + + def DELETE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DELETE) + else: + return self.getToken(PLpgSQLParser.DELETE, i) + + def UPDATE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.UPDATE) + else: + return self.getToken(PLpgSQLParser.UPDATE, i) + + def CHECK(self): + return self.getToken(PLpgSQLParser.CHECK, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def INHERIT(self): + return self.getToken(PLpgSQLParser.INHERIT, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def UNIQUE(self): + return self.getToken(PLpgSQLParser.UNIQUE, 0) + + def PRIMARY(self): + return self.getToken(PLpgSQLParser.PRIMARY, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def identity_body(self): + return self.getTypedRuleContext(PLpgSQLParser.Identity_bodyContext,0) + + + def GENERATED(self): + return self.getToken(PLpgSQLParser.GENERATED, 0) + + def ALWAYS(self): + return self.getToken(PLpgSQLParser.ALWAYS, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def STORED(self): + return self.getToken(PLpgSQLParser.STORED, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_constr_body + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConstr_body" ): + listener.enterConstr_body(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConstr_body" ): + listener.exitConstr_body(self) + + + + + def constr_body(self): + + localctx = PLpgSQLParser.Constr_bodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 460, self.RULE_constr_body) + self._la = 0 # Token type + try: + self.state = 5038 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,617,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4961 + self.match(PLpgSQLParser.EXCLUDE) + self.state = 4964 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 4962 + self.match(PLpgSQLParser.USING) + self.state = 4963 + localctx.index_method = self.identifier() + + + self.state = 4966 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 4967 + self.sort_specifier() + self.state = 4968 + self.match(PLpgSQLParser.WITH) + self.state = 4969 + self.all_op() + self.state = 4977 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 4970 + self.match(PLpgSQLParser.COMMA) + self.state = 4971 + self.sort_specifier() + self.state = 4972 + self.match(PLpgSQLParser.WITH) + self.state = 4973 + self.all_op() + self.state = 4979 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4980 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 4981 + self.index_parameters() + self.state = 4984 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 4982 + localctx.where = self.match(PLpgSQLParser.WHERE) + self.state = 4983 + localctx.exp = self.vex(0) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4989 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOREIGN: + self.state = 4986 + self.match(PLpgSQLParser.FOREIGN) + self.state = 4987 + self.match(PLpgSQLParser.KEY) + self.state = 4988 + self.names_in_parens() + + + self.state = 4991 + self.match(PLpgSQLParser.REFERENCES) + self.state = 4992 + self.schema_qualified_name() + self.state = 4994 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 4993 + localctx.ref = self.names_in_parens() + + + self.state = 5003 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.MATCH or _la==PLpgSQLParser.ON: + self.state = 5001 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.MATCH]: + self.state = 4996 + self.match(PLpgSQLParser.MATCH) + self.state = 4997 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PARTIAL or _la==PLpgSQLParser.SIMPLE or _la==PLpgSQLParser.FULL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.ON]: + self.state = 4998 + self.match(PLpgSQLParser.ON) + self.state = 4999 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DELETE or _la==PLpgSQLParser.UPDATE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5000 + self.action() + pass + else: + raise NoViableAltException(self) + + self.state = 5005 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5006 + self.match(PLpgSQLParser.CHECK) + self.state = 5007 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5008 + localctx.expression = self.vex(0) + self.state = 5009 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5012 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 5010 + self.match(PLpgSQLParser.NO) + self.state = 5011 + self.match(PLpgSQLParser.INHERIT) + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5015 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5014 + self.match(PLpgSQLParser.NOT) + + + self.state = 5017 + self.match(PLpgSQLParser.NULL) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 5021 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.UNIQUE]: + self.state = 5018 + self.match(PLpgSQLParser.UNIQUE) + pass + elif token in [PLpgSQLParser.PRIMARY]: + self.state = 5019 + self.match(PLpgSQLParser.PRIMARY) + self.state = 5020 + self.match(PLpgSQLParser.KEY) + pass + else: + raise NoViableAltException(self) + + self.state = 5024 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 5023 + localctx.col = self.names_in_parens() + + + self.state = 5026 + self.index_parameters() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 5027 + self.match(PLpgSQLParser.DEFAULT) + self.state = 5028 + localctx.default_expr = self.vex(0) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 5029 + self.identity_body() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 5030 + self.match(PLpgSQLParser.GENERATED) + self.state = 5031 + self.match(PLpgSQLParser.ALWAYS) + self.state = 5032 + self.match(PLpgSQLParser.AS) + self.state = 5033 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5034 + self.vex(0) + self.state = 5035 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5036 + self.match(PLpgSQLParser.STORED) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class All_opContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def op(self): + return self.getTypedRuleContext(PLpgSQLParser.OpContext,0) + + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def NOT_EQUAL(self): + return self.getToken(PLpgSQLParser.NOT_EQUAL, 0) + + def LTH(self): + return self.getToken(PLpgSQLParser.LTH, 0) + + def LEQ(self): + return self.getToken(PLpgSQLParser.LEQ, 0) + + def GTH(self): + return self.getToken(PLpgSQLParser.GTH, 0) + + def GEQ(self): + return self.getToken(PLpgSQLParser.GEQ, 0) + + def PLUS(self): + return self.getToken(PLpgSQLParser.PLUS, 0) + + def MINUS(self): + return self.getToken(PLpgSQLParser.MINUS, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def DIVIDE(self): + return self.getToken(PLpgSQLParser.DIVIDE, 0) + + def MODULAR(self): + return self.getToken(PLpgSQLParser.MODULAR, 0) + + def EXP(self): + return self.getToken(PLpgSQLParser.EXP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_all_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAll_op" ): + listener.enterAll_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAll_op" ): + listener.exitAll_op(self) + + + + + def all_op(self): + + localctx = PLpgSQLParser.All_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 462, self.RULE_all_op) + try: + self.state = 5053 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.OPERATOR, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS]: + self.enterOuterAlt(localctx, 1) + self.state = 5040 + self.op() + pass + elif token in [PLpgSQLParser.EQUAL]: + self.enterOuterAlt(localctx, 2) + self.state = 5041 + self.match(PLpgSQLParser.EQUAL) + pass + elif token in [PLpgSQLParser.NOT_EQUAL]: + self.enterOuterAlt(localctx, 3) + self.state = 5042 + self.match(PLpgSQLParser.NOT_EQUAL) + pass + elif token in [PLpgSQLParser.LTH]: + self.enterOuterAlt(localctx, 4) + self.state = 5043 + self.match(PLpgSQLParser.LTH) + pass + elif token in [PLpgSQLParser.LEQ]: + self.enterOuterAlt(localctx, 5) + self.state = 5044 + self.match(PLpgSQLParser.LEQ) + pass + elif token in [PLpgSQLParser.GTH]: + self.enterOuterAlt(localctx, 6) + self.state = 5045 + self.match(PLpgSQLParser.GTH) + pass + elif token in [PLpgSQLParser.GEQ]: + self.enterOuterAlt(localctx, 7) + self.state = 5046 + self.match(PLpgSQLParser.GEQ) + pass + elif token in [PLpgSQLParser.PLUS]: + self.enterOuterAlt(localctx, 8) + self.state = 5047 + self.match(PLpgSQLParser.PLUS) + pass + elif token in [PLpgSQLParser.MINUS]: + self.enterOuterAlt(localctx, 9) + self.state = 5048 + self.match(PLpgSQLParser.MINUS) + pass + elif token in [PLpgSQLParser.MULTIPLY]: + self.enterOuterAlt(localctx, 10) + self.state = 5049 + self.match(PLpgSQLParser.MULTIPLY) + pass + elif token in [PLpgSQLParser.DIVIDE]: + self.enterOuterAlt(localctx, 11) + self.state = 5050 + self.match(PLpgSQLParser.DIVIDE) + pass + elif token in [PLpgSQLParser.MODULAR]: + self.enterOuterAlt(localctx, 12) + self.state = 5051 + self.match(PLpgSQLParser.MODULAR) + pass + elif token in [PLpgSQLParser.EXP]: + self.enterOuterAlt(localctx, 13) + self.state = 5052 + self.match(PLpgSQLParser.EXP) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class All_simple_opContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def op_chars(self): + return self.getTypedRuleContext(PLpgSQLParser.Op_charsContext,0) + + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def NOT_EQUAL(self): + return self.getToken(PLpgSQLParser.NOT_EQUAL, 0) + + def LTH(self): + return self.getToken(PLpgSQLParser.LTH, 0) + + def LEQ(self): + return self.getToken(PLpgSQLParser.LEQ, 0) + + def GTH(self): + return self.getToken(PLpgSQLParser.GTH, 0) + + def GEQ(self): + return self.getToken(PLpgSQLParser.GEQ, 0) + + def PLUS(self): + return self.getToken(PLpgSQLParser.PLUS, 0) + + def MINUS(self): + return self.getToken(PLpgSQLParser.MINUS, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def DIVIDE(self): + return self.getToken(PLpgSQLParser.DIVIDE, 0) + + def MODULAR(self): + return self.getToken(PLpgSQLParser.MODULAR, 0) + + def EXP(self): + return self.getToken(PLpgSQLParser.EXP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_all_simple_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAll_simple_op" ): + listener.enterAll_simple_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAll_simple_op" ): + listener.exitAll_simple_op(self) + + + + + def all_simple_op(self): + + localctx = PLpgSQLParser.All_simple_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 464, self.RULE_all_simple_op) + try: + self.state = 5068 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS]: + self.enterOuterAlt(localctx, 1) + self.state = 5055 + self.op_chars() + pass + elif token in [PLpgSQLParser.EQUAL]: + self.enterOuterAlt(localctx, 2) + self.state = 5056 + self.match(PLpgSQLParser.EQUAL) + pass + elif token in [PLpgSQLParser.NOT_EQUAL]: + self.enterOuterAlt(localctx, 3) + self.state = 5057 + self.match(PLpgSQLParser.NOT_EQUAL) + pass + elif token in [PLpgSQLParser.LTH]: + self.enterOuterAlt(localctx, 4) + self.state = 5058 + self.match(PLpgSQLParser.LTH) + pass + elif token in [PLpgSQLParser.LEQ]: + self.enterOuterAlt(localctx, 5) + self.state = 5059 + self.match(PLpgSQLParser.LEQ) + pass + elif token in [PLpgSQLParser.GTH]: + self.enterOuterAlt(localctx, 6) + self.state = 5060 + self.match(PLpgSQLParser.GTH) + pass + elif token in [PLpgSQLParser.GEQ]: + self.enterOuterAlt(localctx, 7) + self.state = 5061 + self.match(PLpgSQLParser.GEQ) + pass + elif token in [PLpgSQLParser.PLUS]: + self.enterOuterAlt(localctx, 8) + self.state = 5062 + self.match(PLpgSQLParser.PLUS) + pass + elif token in [PLpgSQLParser.MINUS]: + self.enterOuterAlt(localctx, 9) + self.state = 5063 + self.match(PLpgSQLParser.MINUS) + pass + elif token in [PLpgSQLParser.MULTIPLY]: + self.enterOuterAlt(localctx, 10) + self.state = 5064 + self.match(PLpgSQLParser.MULTIPLY) + pass + elif token in [PLpgSQLParser.DIVIDE]: + self.enterOuterAlt(localctx, 11) + self.state = 5065 + self.match(PLpgSQLParser.DIVIDE) + pass + elif token in [PLpgSQLParser.MODULAR]: + self.enterOuterAlt(localctx, 12) + self.state = 5066 + self.match(PLpgSQLParser.MODULAR) + pass + elif token in [PLpgSQLParser.EXP]: + self.enterOuterAlt(localctx, 13) + self.state = 5067 + self.match(PLpgSQLParser.EXP) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Op_charsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OP_CHARS(self): + return self.getToken(PLpgSQLParser.OP_CHARS, 0) + + def LESS_LESS(self): + return self.getToken(PLpgSQLParser.LESS_LESS, 0) + + def GREATER_GREATER(self): + return self.getToken(PLpgSQLParser.GREATER_GREATER, 0) + + def HASH_SIGN(self): + return self.getToken(PLpgSQLParser.HASH_SIGN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_op_chars + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOp_chars" ): + listener.enterOp_chars(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOp_chars" ): + listener.exitOp_chars(self) + + + + + def op_chars(self): + + localctx = PLpgSQLParser.Op_charsContext(self, self._ctx, self.state) + self.enterRule(localctx, 466, self.RULE_op_chars) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5070 + _la = self._input.LA(1) + if not(((((_la - 601)) & ~0x3f) == 0 and ((1 << (_la - 601)) & ((1 << (PLpgSQLParser.LESS_LESS - 601)) | (1 << (PLpgSQLParser.GREATER_GREATER - 601)) | (1 << (PLpgSQLParser.HASH_SIGN - 601)) | (1 << (PLpgSQLParser.OP_CHARS - 601)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Index_parametersContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def including_index(self): + return self.getTypedRuleContext(PLpgSQLParser.Including_indexContext,0) + + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def table_space(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_spaceContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_index_parameters + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndex_parameters" ): + listener.enterIndex_parameters(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndex_parameters" ): + listener.exitIndex_parameters(self) + + + + + def index_parameters(self): + + localctx = PLpgSQLParser.Index_parametersContext(self, self._ctx, self.state) + self.enterRule(localctx, 468, self.RULE_index_parameters) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5073 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.INCLUDE: + self.state = 5072 + self.including_index() + + + self.state = 5076 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 5075 + self.with_storage_parameter() + + + self.state = 5084 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 5078 + self.match(PLpgSQLParser.USING) + self.state = 5079 + self.match(PLpgSQLParser.INDEX) + self.state = 5082 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,622,self._ctx) + if la_ == 1: + self.state = 5080 + self.table_space() + pass + + elif la_ == 2: + self.state = 5081 + self.schema_qualified_name() + pass + + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Names_in_parensContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def names_references(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_referencesContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_names_in_parens + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNames_in_parens" ): + listener.enterNames_in_parens(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNames_in_parens" ): + listener.exitNames_in_parens(self) + + + + + def names_in_parens(self): + + localctx = PLpgSQLParser.Names_in_parensContext(self, self._ctx, self.state) + self.enterRule(localctx, 470, self.RULE_names_in_parens) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5086 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5087 + self.names_references() + self.state = 5088 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Names_referencesContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_names_references + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNames_references" ): + listener.enterNames_references(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNames_references" ): + listener.exitNames_references(self) + + + + + def names_references(self): + + localctx = PLpgSQLParser.Names_referencesContext(self, self._ctx, self.state) + self.enterRule(localctx, 472, self.RULE_names_references) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5090 + self.schema_qualified_name() + self.state = 5095 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5091 + self.match(PLpgSQLParser.COMMA) + self.state = 5092 + self.schema_qualified_name() + self.state = 5097 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Storage_parameterContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def storage_parameter_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Storage_parameter_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameter_optionContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_storage_parameter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStorage_parameter" ): + listener.enterStorage_parameter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStorage_parameter" ): + listener.exitStorage_parameter(self) + + + + + def storage_parameter(self): + + localctx = PLpgSQLParser.Storage_parameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 474, self.RULE_storage_parameter) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5098 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5099 + self.storage_parameter_option() + self.state = 5104 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5100 + self.match(PLpgSQLParser.COMMA) + self.state = 5101 + self.storage_parameter_option() + self.state = 5106 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5107 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Storage_parameter_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def storage_parameter_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameter_nameContext,0) + + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_storage_parameter_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStorage_parameter_option" ): + listener.enterStorage_parameter_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStorage_parameter_option" ): + listener.exitStorage_parameter_option(self) + + + + + def storage_parameter_option(self): + + localctx = PLpgSQLParser.Storage_parameter_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 476, self.RULE_storage_parameter_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5109 + self.storage_parameter_name() + self.state = 5112 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.EQUAL: + self.state = 5110 + self.match(PLpgSQLParser.EQUAL) + self.state = 5111 + self.vex(0) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Storage_parameter_nameContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def col_label(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Col_labelContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Col_labelContext,i) + + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_storage_parameter_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStorage_parameter_name" ): + listener.enterStorage_parameter_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStorage_parameter_name" ): + listener.exitStorage_parameter_name(self) + + + + + def storage_parameter_name(self): + + localctx = PLpgSQLParser.Storage_parameter_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 478, self.RULE_storage_parameter_name) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5114 + self.col_label() + self.state = 5117 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DOT: + self.state = 5115 + self.match(PLpgSQLParser.DOT) + self.state = 5116 + self.col_label() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class With_storage_parameterContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.Storage_parameterContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_with_storage_parameter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWith_storage_parameter" ): + listener.enterWith_storage_parameter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWith_storage_parameter" ): + listener.exitWith_storage_parameter(self) + + + + + def with_storage_parameter(self): + + localctx = PLpgSQLParser.With_storage_parameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 480, self.RULE_with_storage_parameter) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5119 + self.match(PLpgSQLParser.WITH) + self.state = 5120 + self.storage_parameter() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Storage_parameter_oidContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def with_storage_parameter(self): + return self.getTypedRuleContext(PLpgSQLParser.With_storage_parameterContext,0) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def OIDS(self): + return self.getToken(PLpgSQLParser.OIDS, 0) + + def WITHOUT(self): + return self.getToken(PLpgSQLParser.WITHOUT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_storage_parameter_oid + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStorage_parameter_oid" ): + listener.enterStorage_parameter_oid(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStorage_parameter_oid" ): + listener.exitStorage_parameter_oid(self) + + + + + def storage_parameter_oid(self): + + localctx = PLpgSQLParser.Storage_parameter_oidContext(self, self._ctx, self.state) + self.enterRule(localctx, 482, self.RULE_storage_parameter_oid) + try: + self.state = 5127 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,628,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5122 + self.with_storage_parameter() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5123 + self.match(PLpgSQLParser.WITH) + self.state = 5124 + self.match(PLpgSQLParser.OIDS) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5125 + self.match(PLpgSQLParser.WITHOUT) + self.state = 5126 + self.match(PLpgSQLParser.OIDS) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class On_commitContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def COMMIT(self): + return self.getToken(PLpgSQLParser.COMMIT, 0) + + def PRESERVE(self): + return self.getToken(PLpgSQLParser.PRESERVE, 0) + + def ROWS(self): + return self.getToken(PLpgSQLParser.ROWS, 0) + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_on_commit + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOn_commit" ): + listener.enterOn_commit(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOn_commit" ): + listener.exitOn_commit(self) + + + + + def on_commit(self): + + localctx = PLpgSQLParser.On_commitContext(self, self._ctx, self.state) + self.enterRule(localctx, 484, self.RULE_on_commit) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5129 + self.match(PLpgSQLParser.ON) + self.state = 5130 + self.match(PLpgSQLParser.COMMIT) + self.state = 5136 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.PRESERVE]: + self.state = 5131 + self.match(PLpgSQLParser.PRESERVE) + self.state = 5132 + self.match(PLpgSQLParser.ROWS) + pass + elif token in [PLpgSQLParser.DELETE]: + self.state = 5133 + self.match(PLpgSQLParser.DELETE) + self.state = 5134 + self.match(PLpgSQLParser.ROWS) + pass + elif token in [PLpgSQLParser.DROP]: + self.state = 5135 + self.match(PLpgSQLParser.DROP) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_spaceContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_space + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_space" ): + listener.enterTable_space(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_space" ): + listener.exitTable_space(self) + + + + + def table_space(self): + + localctx = PLpgSQLParser.Table_spaceContext(self, self._ctx, self.state) + self.enterRule(localctx, 486, self.RULE_table_space) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5138 + self.match(PLpgSQLParser.TABLESPACE) + self.state = 5139 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ActionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def ACTION(self): + return self.getToken(PLpgSQLParser.ACTION, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAction" ): + listener.enterAction(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAction" ): + listener.exitAction(self) + + + + + def action(self): + + localctx = PLpgSQLParser.ActionContext(self, self._ctx, self.state) + self.enterRule(localctx, 488, self.RULE_action) + self._la = 0 # Token type + try: + self.state = 5146 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CASCADE, PLpgSQLParser.RESTRICT]: + self.enterOuterAlt(localctx, 1) + self.state = 5141 + self.cascade_restrict() + pass + elif token in [PLpgSQLParser.SET]: + self.enterOuterAlt(localctx, 2) + self.state = 5142 + self.match(PLpgSQLParser.SET) + self.state = 5143 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DEFAULT or _la==PLpgSQLParser.NULL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + elif token in [PLpgSQLParser.NO]: + self.enterOuterAlt(localctx, 3) + self.state = 5144 + self.match(PLpgSQLParser.NO) + self.state = 5145 + self.match(PLpgSQLParser.ACTION) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Owner_toContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def OWNER(self): + return self.getToken(PLpgSQLParser.OWNER, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def CURRENT_USER(self): + return self.getToken(PLpgSQLParser.CURRENT_USER, 0) + + def SESSION_USER(self): + return self.getToken(PLpgSQLParser.SESSION_USER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_owner_to + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOwner_to" ): + listener.enterOwner_to(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOwner_to" ): + listener.exitOwner_to(self) + + + + + def owner_to(self): + + localctx = PLpgSQLParser.Owner_toContext(self, self._ctx, self.state) + self.enterRule(localctx, 490, self.RULE_owner_to) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5148 + self.match(PLpgSQLParser.OWNER) + self.state = 5149 + self.match(PLpgSQLParser.TO) + self.state = 5153 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 5150 + localctx.name = self.identifier() + pass + elif token in [PLpgSQLParser.CURRENT_USER]: + self.state = 5151 + self.match(PLpgSQLParser.CURRENT_USER) + pass + elif token in [PLpgSQLParser.SESSION_USER]: + self.state = 5152 + self.match(PLpgSQLParser.SESSION_USER) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Rename_toContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def RENAME(self): + return self.getToken(PLpgSQLParser.RENAME, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_rename_to + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRename_to" ): + listener.enterRename_to(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRename_to" ): + listener.exitRename_to(self) + + + + + def rename_to(self): + + localctx = PLpgSQLParser.Rename_toContext(self, self._ctx, self.state) + self.enterRule(localctx, 492, self.RULE_rename_to) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5155 + self.match(PLpgSQLParser.RENAME) + self.state = 5156 + self.match(PLpgSQLParser.TO) + self.state = 5157 + localctx.name = self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Set_schemaContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_set_schema + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet_schema" ): + listener.enterSet_schema(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet_schema" ): + listener.exitSet_schema(self) + + + + + def set_schema(self): + + localctx = PLpgSQLParser.Set_schemaContext(self, self._ctx, self.state) + self.enterRule(localctx, 494, self.RULE_set_schema) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5159 + self.match(PLpgSQLParser.SET) + self.state = 5160 + self.match(PLpgSQLParser.SCHEMA) + self.state = 5161 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_column_privilegeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def INSERT(self): + return self.getToken(PLpgSQLParser.INSERT, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def TRUNCATE(self): + return self.getToken(PLpgSQLParser.TRUNCATE, 0) + + def REFERENCES(self): + return self.getToken(PLpgSQLParser.REFERENCES, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def PRIVILEGES(self): + return self.getToken(PLpgSQLParser.PRIVILEGES, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_column_privilege + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_column_privilege" ): + listener.enterTable_column_privilege(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_column_privilege" ): + listener.exitTable_column_privilege(self) + + + + + def table_column_privilege(self): + + localctx = PLpgSQLParser.Table_column_privilegeContext(self, self._ctx, self.state) + self.enterRule(localctx, 496, self.RULE_table_column_privilege) + self._la = 0 # Token type + try: + self.state = 5174 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SELECT]: + self.enterOuterAlt(localctx, 1) + self.state = 5163 + self.match(PLpgSQLParser.SELECT) + pass + elif token in [PLpgSQLParser.INSERT]: + self.enterOuterAlt(localctx, 2) + self.state = 5164 + self.match(PLpgSQLParser.INSERT) + pass + elif token in [PLpgSQLParser.UPDATE]: + self.enterOuterAlt(localctx, 3) + self.state = 5165 + self.match(PLpgSQLParser.UPDATE) + pass + elif token in [PLpgSQLParser.DELETE]: + self.enterOuterAlt(localctx, 4) + self.state = 5166 + self.match(PLpgSQLParser.DELETE) + pass + elif token in [PLpgSQLParser.TRUNCATE]: + self.enterOuterAlt(localctx, 5) + self.state = 5167 + self.match(PLpgSQLParser.TRUNCATE) + pass + elif token in [PLpgSQLParser.REFERENCES]: + self.enterOuterAlt(localctx, 6) + self.state = 5168 + self.match(PLpgSQLParser.REFERENCES) + pass + elif token in [PLpgSQLParser.TRIGGER]: + self.enterOuterAlt(localctx, 7) + self.state = 5169 + self.match(PLpgSQLParser.TRIGGER) + pass + elif token in [PLpgSQLParser.ALL]: + self.enterOuterAlt(localctx, 8) + self.state = 5170 + self.match(PLpgSQLParser.ALL) + self.state = 5172 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PRIVILEGES: + self.state = 5171 + self.match(PLpgSQLParser.PRIVILEGES) + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Usage_select_updateContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USAGE(self): + return self.getToken(PLpgSQLParser.USAGE, 0) + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_usage_select_update + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUsage_select_update" ): + listener.enterUsage_select_update(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUsage_select_update" ): + listener.exitUsage_select_update(self) + + + + + def usage_select_update(self): + + localctx = PLpgSQLParser.Usage_select_updateContext(self, self._ctx, self.state) + self.enterRule(localctx, 498, self.RULE_usage_select_update) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5176 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.UPDATE or _la==PLpgSQLParser.SELECT or _la==PLpgSQLParser.USAGE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Partition_by_columnsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PARTITION(self): + return self.getToken(PLpgSQLParser.PARTITION, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_partition_by_columns + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPartition_by_columns" ): + listener.enterPartition_by_columns(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPartition_by_columns" ): + listener.exitPartition_by_columns(self) + + + + + def partition_by_columns(self): + + localctx = PLpgSQLParser.Partition_by_columnsContext(self, self._ctx, self.state) + self.enterRule(localctx, 500, self.RULE_partition_by_columns) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5178 + self.match(PLpgSQLParser.PARTITION) + self.state = 5179 + self.match(PLpgSQLParser.BY) + self.state = 5180 + self.vex(0) + self.state = 5185 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5181 + self.match(PLpgSQLParser.COMMA) + self.state = 5182 + self.vex(0) + self.state = 5187 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Cascade_restrictContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CASCADE(self): + return self.getToken(PLpgSQLParser.CASCADE, 0) + + def RESTRICT(self): + return self.getToken(PLpgSQLParser.RESTRICT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_cascade_restrict + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCascade_restrict" ): + listener.enterCascade_restrict(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCascade_restrict" ): + listener.exitCascade_restrict(self) + + + + + def cascade_restrict(self): + + localctx = PLpgSQLParser.Cascade_restrictContext(self, self._ctx, self.state) + self.enterRule(localctx, 502, self.RULE_cascade_restrict) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5188 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Collate_identifierContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.collation = None # Schema_qualified_nameContext + + def COLLATE(self): + return self.getToken(PLpgSQLParser.COLLATE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_collate_identifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCollate_identifier" ): + listener.enterCollate_identifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCollate_identifier" ): + listener.exitCollate_identifier(self) + + + + + def collate_identifier(self): + + localctx = PLpgSQLParser.Collate_identifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 504, self.RULE_collate_identifier) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5190 + self.match(PLpgSQLParser.COLLATE) + self.state = 5191 + localctx.collation = self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Indirection_varContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def dollar_number(self): + return self.getTypedRuleContext(PLpgSQLParser.Dollar_numberContext,0) + + + def indirection_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Indirection_listContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_indirection_var + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndirection_var" ): + listener.enterIndirection_var(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndirection_var" ): + listener.exitIndirection_var(self) + + + + + def indirection_var(self): + + localctx = PLpgSQLParser.Indirection_varContext(self, self._ctx, self.state) + self.enterRule(localctx, 506, self.RULE_indirection_var) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5195 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 5193 + self.identifier() + pass + elif token in [PLpgSQLParser.DOLLAR_NUMBER]: + self.state = 5194 + self.dollar_number() + pass + else: + raise NoViableAltException(self) + + self.state = 5198 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,636,self._ctx) + if la_ == 1: + self.state = 5197 + self.indirection_list() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Dollar_numberContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOLLAR_NUMBER(self): + return self.getToken(PLpgSQLParser.DOLLAR_NUMBER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_dollar_number + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDollar_number" ): + listener.enterDollar_number(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDollar_number" ): + listener.exitDollar_number(self) + + + + + def dollar_number(self): + + localctx = PLpgSQLParser.Dollar_numberContext(self, self._ctx, self.state) + self.enterRule(localctx, 508, self.RULE_dollar_number) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5200 + self.match(PLpgSQLParser.DOLLAR_NUMBER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Indirection_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def indirection(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IndirectionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IndirectionContext,i) + + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_indirection_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndirection_list" ): + listener.enterIndirection_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndirection_list" ): + listener.exitIndirection_list(self) + + + + + def indirection_list(self): + + localctx = PLpgSQLParser.Indirection_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 510, self.RULE_indirection_list) + try: + self.state = 5215 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,639,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5203 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 5202 + self.indirection() + + else: + raise NoViableAltException(self) + self.state = 5205 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,637,self._ctx) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5210 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,638,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5207 + self.indirection() + self.state = 5212 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,638,self._ctx) + + self.state = 5213 + self.match(PLpgSQLParser.DOT) + self.state = 5214 + self.match(PLpgSQLParser.MULTIPLY) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IndirectionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def col_label(self): + return self.getTypedRuleContext(PLpgSQLParser.Col_labelContext,0) + + + def LEFT_BRACKET(self): + return self.getToken(PLpgSQLParser.LEFT_BRACKET, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_BRACKET(self): + return self.getToken(PLpgSQLParser.RIGHT_BRACKET, 0) + + def COLON(self): + return self.getToken(PLpgSQLParser.COLON, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_indirection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndirection" ): + listener.enterIndirection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndirection" ): + listener.exitIndirection(self) + + + + + def indirection(self): + + localctx = PLpgSQLParser.IndirectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 512, self.RULE_indirection) + self._la = 0 # Token type + try: + self.state = 5232 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,642,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5217 + self.match(PLpgSQLParser.DOT) + self.state = 5218 + self.col_label() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5219 + self.match(PLpgSQLParser.LEFT_BRACKET) + self.state = 5220 + self.vex(0) + self.state = 5221 + self.match(PLpgSQLParser.RIGHT_BRACKET) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5223 + self.match(PLpgSQLParser.LEFT_BRACKET) + self.state = 5225 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 5224 + self.vex(0) + + + self.state = 5227 + self.match(PLpgSQLParser.COLON) + self.state = 5229 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 5228 + self.vex(0) + + + self.state = 5231 + self.match(PLpgSQLParser.RIGHT_BRACKET) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_function_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # Schema_qualified_nameContext + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def function_args(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_argsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_function_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_function_statement" ): + listener.enterDrop_function_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_function_statement" ): + listener.exitDrop_function_statement(self) + + + + + def drop_function_statement(self): + + localctx = PLpgSQLParser.Drop_function_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 514, self.RULE_drop_function_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5234 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.AGGREGATE or _la==PLpgSQLParser.FUNCTION or _la==PLpgSQLParser.PROCEDURE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5236 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,643,self._ctx) + if la_ == 1: + self.state = 5235 + self.if_exists() + + + self.state = 5238 + localctx.name = self.schema_qualified_name() + self.state = 5240 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 5239 + self.function_args() + + + self.state = 5243 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 5242 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_trigger_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.table_name = None # Schema_qualified_nameContext + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_trigger_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_trigger_statement" ): + listener.enterDrop_trigger_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_trigger_statement" ): + listener.exitDrop_trigger_statement(self) + + + + + def drop_trigger_statement(self): + + localctx = PLpgSQLParser.Drop_trigger_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 516, self.RULE_drop_trigger_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5245 + self.match(PLpgSQLParser.TRIGGER) + self.state = 5247 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,646,self._ctx) + if la_ == 1: + self.state = 5246 + self.if_exists() + + + self.state = 5249 + localctx.name = self.identifier() + self.state = 5250 + self.match(PLpgSQLParser.ON) + self.state = 5251 + localctx.table_name = self.schema_qualified_name() + self.state = 5253 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 5252 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_rule_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def RULE(self): + return self.getToken(PLpgSQLParser.RULE, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_rule_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_rule_statement" ): + listener.enterDrop_rule_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_rule_statement" ): + listener.exitDrop_rule_statement(self) + + + + + def drop_rule_statement(self): + + localctx = PLpgSQLParser.Drop_rule_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 518, self.RULE_drop_rule_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5255 + self.match(PLpgSQLParser.RULE) + self.state = 5257 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,648,self._ctx) + if la_ == 1: + self.state = 5256 + self.if_exists() + + + self.state = 5259 + localctx.name = self.identifier() + self.state = 5260 + self.match(PLpgSQLParser.ON) + self.state = 5261 + self.schema_qualified_name() + self.state = 5263 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 5262 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Drop_statementsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def if_exist_names_restrict_cascade(self): + return self.getTypedRuleContext(PLpgSQLParser.If_exist_names_restrict_cascadeContext,0) + + + def ACCESS(self): + return self.getToken(PLpgSQLParser.ACCESS, 0) + + def METHOD(self): + return self.getToken(PLpgSQLParser.METHOD, 0) + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def CONVERSION(self): + return self.getToken(PLpgSQLParser.CONVERSION, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def SUBSCRIPTION(self): + return self.getToken(PLpgSQLParser.SUBSCRIPTION, 0) + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def CONCURRENTLY(self): + return self.getToken(PLpgSQLParser.CONCURRENTLY, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_drop_statements + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDrop_statements" ): + listener.enterDrop_statements(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDrop_statements" ): + listener.exitDrop_statements(self) + + + + + def drop_statements(self): + + localctx = PLpgSQLParser.Drop_statementsContext(self, self._ctx, self.state) + self.enterRule(localctx, 520, self.RULE_drop_statements) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5307 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,654,self._ctx) + if la_ == 1: + self.state = 5265 + self.match(PLpgSQLParser.ACCESS) + self.state = 5266 + self.match(PLpgSQLParser.METHOD) + pass + + elif la_ == 2: + self.state = 5267 + self.match(PLpgSQLParser.COLLATION) + pass + + elif la_ == 3: + self.state = 5268 + self.match(PLpgSQLParser.CONVERSION) + pass + + elif la_ == 4: + self.state = 5269 + self.match(PLpgSQLParser.DATABASE) + pass + + elif la_ == 5: + self.state = 5270 + self.match(PLpgSQLParser.DOMAIN) + pass + + elif la_ == 6: + self.state = 5271 + self.match(PLpgSQLParser.EVENT) + self.state = 5272 + self.match(PLpgSQLParser.TRIGGER) + pass + + elif la_ == 7: + self.state = 5273 + self.match(PLpgSQLParser.EXTENSION) + pass + + elif la_ == 8: + self.state = 5274 + self.match(PLpgSQLParser.GROUP) + pass + + elif la_ == 9: + self.state = 5276 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOREIGN: + self.state = 5275 + self.match(PLpgSQLParser.FOREIGN) + + + self.state = 5278 + self.match(PLpgSQLParser.TABLE) + pass + + elif la_ == 10: + self.state = 5279 + self.match(PLpgSQLParser.FOREIGN) + self.state = 5280 + self.match(PLpgSQLParser.DATA) + self.state = 5281 + self.match(PLpgSQLParser.WRAPPER) + pass + + elif la_ == 11: + self.state = 5282 + self.match(PLpgSQLParser.INDEX) + self.state = 5284 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONCURRENTLY: + self.state = 5283 + self.match(PLpgSQLParser.CONCURRENTLY) + + + pass + + elif la_ == 12: + self.state = 5287 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED: + self.state = 5286 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 5289 + self.match(PLpgSQLParser.VIEW) + pass + + elif la_ == 13: + self.state = 5291 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PROCEDURAL: + self.state = 5290 + self.match(PLpgSQLParser.PROCEDURAL) + + + self.state = 5293 + self.match(PLpgSQLParser.LANGUAGE) + pass + + elif la_ == 14: + self.state = 5294 + self.match(PLpgSQLParser.PUBLICATION) + pass + + elif la_ == 15: + self.state = 5295 + self.match(PLpgSQLParser.ROLE) + pass + + elif la_ == 16: + self.state = 5296 + self.match(PLpgSQLParser.SCHEMA) + pass + + elif la_ == 17: + self.state = 5297 + self.match(PLpgSQLParser.SEQUENCE) + pass + + elif la_ == 18: + self.state = 5298 + self.match(PLpgSQLParser.SERVER) + pass + + elif la_ == 19: + self.state = 5299 + self.match(PLpgSQLParser.STATISTICS) + pass + + elif la_ == 20: + self.state = 5300 + self.match(PLpgSQLParser.SUBSCRIPTION) + pass + + elif la_ == 21: + self.state = 5301 + self.match(PLpgSQLParser.TABLESPACE) + pass + + elif la_ == 22: + self.state = 5302 + self.match(PLpgSQLParser.TYPE) + pass + + elif la_ == 23: + self.state = 5303 + self.match(PLpgSQLParser.TEXT) + self.state = 5304 + self.match(PLpgSQLParser.SEARCH) + self.state = 5305 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONFIGURATION or _la==PLpgSQLParser.DICTIONARY or _la==PLpgSQLParser.PARSER or _la==PLpgSQLParser.TEMPLATE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 24: + self.state = 5306 + self.match(PLpgSQLParser.USER) + pass + + + self.state = 5309 + self.if_exist_names_restrict_cascade() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class If_exist_names_restrict_cascadeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def names_references(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_referencesContext,0) + + + def if_exists(self): + return self.getTypedRuleContext(PLpgSQLParser.If_existsContext,0) + + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_if_exist_names_restrict_cascade + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIf_exist_names_restrict_cascade" ): + listener.enterIf_exist_names_restrict_cascade(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIf_exist_names_restrict_cascade" ): + listener.exitIf_exist_names_restrict_cascade(self) + + + + + def if_exist_names_restrict_cascade(self): + + localctx = PLpgSQLParser.If_exist_names_restrict_cascadeContext(self, self._ctx, self.state) + self.enterRule(localctx, 522, self.RULE_if_exist_names_restrict_cascade) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5312 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,655,self._ctx) + if la_ == 1: + self.state = 5311 + self.if_exists() + + + self.state = 5314 + self.names_references() + self.state = 5316 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 5315 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Id_tokenContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def Identifier(self): + return self.getToken(PLpgSQLParser.Identifier, 0) + + def QuotedIdentifier(self): + return self.getToken(PLpgSQLParser.QuotedIdentifier, 0) + + def tokens_nonkeyword(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_nonkeywordContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_id_token + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterId_token" ): + listener.enterId_token(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitId_token" ): + listener.exitId_token(self) + + + + + def id_token(self): + + localctx = PLpgSQLParser.Id_tokenContext(self, self._ctx, self.state) + self.enterRule(localctx, 524, self.RULE_id_token) + try: + self.state = 5321 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.Identifier]: + self.enterOuterAlt(localctx, 1) + self.state = 5318 + self.match(PLpgSQLParser.Identifier) + pass + elif token in [PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 2) + self.state = 5319 + self.match(PLpgSQLParser.QuotedIdentifier) + pass + elif token in [PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE]: + self.enterOuterAlt(localctx, 3) + self.state = 5320 + self.tokens_nonkeyword() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IdentifierContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def id_token(self): + return self.getTypedRuleContext(PLpgSQLParser.Id_tokenContext,0) + + + def tokens_nonreserved(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_nonreservedContext,0) + + + def tokens_nonreserved_except_function_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_nonreserved_except_function_typeContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_identifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentifier" ): + listener.enterIdentifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentifier" ): + listener.exitIdentifier(self) + + + + + def identifier(self): + + localctx = PLpgSQLParser.IdentifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 526, self.RULE_identifier) + try: + self.state = 5326 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 1) + self.state = 5323 + self.id_token() + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE]: + self.enterOuterAlt(localctx, 2) + self.state = 5324 + self.tokens_nonreserved() + pass + elif token in [PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE]: + self.enterOuterAlt(localctx, 3) + self.state = 5325 + self.tokens_nonreserved_except_function_type() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Identifier_nontypeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def id_token(self): + return self.getTypedRuleContext(PLpgSQLParser.Id_tokenContext,0) + + + def tokens_nonreserved(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_nonreservedContext,0) + + + def tokens_reserved_except_function_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_reserved_except_function_typeContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_identifier_nontype + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentifier_nontype" ): + listener.enterIdentifier_nontype(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentifier_nontype" ): + listener.exitIdentifier_nontype(self) + + + + + def identifier_nontype(self): + + localctx = PLpgSQLParser.Identifier_nontypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 528, self.RULE_identifier_nontype) + try: + self.state = 5331 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 1) + self.state = 5328 + self.id_token() + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE]: + self.enterOuterAlt(localctx, 2) + self.state = 5329 + self.tokens_nonreserved() + pass + elif token in [PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE]: + self.enterOuterAlt(localctx, 3) + self.state = 5330 + self.tokens_reserved_except_function_type() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Col_labelContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def id_token(self): + return self.getTypedRuleContext(PLpgSQLParser.Id_tokenContext,0) + + + def tokens_reserved(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_reservedContext,0) + + + def tokens_nonreserved(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_nonreservedContext,0) + + + def tokens_reserved_except_function_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_reserved_except_function_typeContext,0) + + + def tokens_nonreserved_except_function_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Tokens_nonreserved_except_function_typeContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_col_label + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCol_label" ): + listener.enterCol_label(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCol_label" ): + listener.exitCol_label(self) + + + + + def col_label(self): + + localctx = PLpgSQLParser.Col_labelContext(self, self._ctx, self.state) + self.enterRule(localctx, 530, self.RULE_col_label) + try: + self.state = 5338 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 1) + self.state = 5333 + self.id_token() + pass + elif token in [PLpgSQLParser.ALL, PLpgSQLParser.ANALYSE, PLpgSQLParser.ANALYZE, PLpgSQLParser.AND, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.AS, PLpgSQLParser.ASC, PLpgSQLParser.ASYMMETRIC, PLpgSQLParser.BOTH, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CHECK, PLpgSQLParser.COLLATE, PLpgSQLParser.COLUMN, PLpgSQLParser.CONSTRAINT, PLpgSQLParser.CREATE, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_ROLE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.DEFAULT, PLpgSQLParser.DEFERRABLE, PLpgSQLParser.DESC, PLpgSQLParser.DISTINCT, PLpgSQLParser.DO, PLpgSQLParser.ELSE, PLpgSQLParser.END, PLpgSQLParser.EXCEPT, PLpgSQLParser.FALSE, PLpgSQLParser.FETCH, PLpgSQLParser.FOR, PLpgSQLParser.FOREIGN, PLpgSQLParser.FROM, PLpgSQLParser.GRANT, PLpgSQLParser.GROUP, PLpgSQLParser.HAVING, PLpgSQLParser.IN, PLpgSQLParser.INITIALLY, PLpgSQLParser.INTERSECT, PLpgSQLParser.INTO, PLpgSQLParser.LATERAL, PLpgSQLParser.LEADING, PLpgSQLParser.LIMIT, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.OFFSET, PLpgSQLParser.ON, PLpgSQLParser.ONLY, PLpgSQLParser.OR, PLpgSQLParser.ORDER, PLpgSQLParser.PLACING, PLpgSQLParser.PRIMARY, PLpgSQLParser.REFERENCES, PLpgSQLParser.RETURNING, PLpgSQLParser.SELECT, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.SYMMETRIC, PLpgSQLParser.TABLE, PLpgSQLParser.THEN, PLpgSQLParser.TO, PLpgSQLParser.TRAILING, PLpgSQLParser.TRUE, PLpgSQLParser.UNION, PLpgSQLParser.UNIQUE, PLpgSQLParser.USER, PLpgSQLParser.USING, PLpgSQLParser.VARIADIC, PLpgSQLParser.WHEN, PLpgSQLParser.WHERE, PLpgSQLParser.WINDOW, PLpgSQLParser.WITH]: + self.enterOuterAlt(localctx, 2) + self.state = 5334 + self.tokens_reserved() + pass + elif token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE]: + self.enterOuterAlt(localctx, 3) + self.state = 5335 + self.tokens_nonreserved() + pass + elif token in [PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE]: + self.enterOuterAlt(localctx, 4) + self.state = 5336 + self.tokens_reserved_except_function_type() + pass + elif token in [PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE]: + self.enterOuterAlt(localctx, 5) + self.state = 5337 + self.tokens_nonreserved_except_function_type() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Tokens_nonreservedContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ABORT(self): + return self.getToken(PLpgSQLParser.ABORT, 0) + + def ABSOLUTE(self): + return self.getToken(PLpgSQLParser.ABSOLUTE, 0) + + def ACCESS(self): + return self.getToken(PLpgSQLParser.ACCESS, 0) + + def ACTION(self): + return self.getToken(PLpgSQLParser.ACTION, 0) + + def ADD(self): + return self.getToken(PLpgSQLParser.ADD, 0) + + def ADMIN(self): + return self.getToken(PLpgSQLParser.ADMIN, 0) + + def AFTER(self): + return self.getToken(PLpgSQLParser.AFTER, 0) + + def AGGREGATE(self): + return self.getToken(PLpgSQLParser.AGGREGATE, 0) + + def ALSO(self): + return self.getToken(PLpgSQLParser.ALSO, 0) + + def ALTER(self): + return self.getToken(PLpgSQLParser.ALTER, 0) + + def ALWAYS(self): + return self.getToken(PLpgSQLParser.ALWAYS, 0) + + def ASSERTION(self): + return self.getToken(PLpgSQLParser.ASSERTION, 0) + + def ASSIGNMENT(self): + return self.getToken(PLpgSQLParser.ASSIGNMENT, 0) + + def AT(self): + return self.getToken(PLpgSQLParser.AT, 0) + + def ATTACH(self): + return self.getToken(PLpgSQLParser.ATTACH, 0) + + def ATTRIBUTE(self): + return self.getToken(PLpgSQLParser.ATTRIBUTE, 0) + + def BACKWARD(self): + return self.getToken(PLpgSQLParser.BACKWARD, 0) + + def BEFORE(self): + return self.getToken(PLpgSQLParser.BEFORE, 0) + + def BEGIN(self): + return self.getToken(PLpgSQLParser.BEGIN, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def CACHE(self): + return self.getToken(PLpgSQLParser.CACHE, 0) + + def CALL(self): + return self.getToken(PLpgSQLParser.CALL, 0) + + def CALLED(self): + return self.getToken(PLpgSQLParser.CALLED, 0) + + def CASCADE(self): + return self.getToken(PLpgSQLParser.CASCADE, 0) + + def CASCADED(self): + return self.getToken(PLpgSQLParser.CASCADED, 0) + + def CATALOG(self): + return self.getToken(PLpgSQLParser.CATALOG, 0) + + def CHAIN(self): + return self.getToken(PLpgSQLParser.CHAIN, 0) + + def CHARACTERISTICS(self): + return self.getToken(PLpgSQLParser.CHARACTERISTICS, 0) + + def CHECKPOINT(self): + return self.getToken(PLpgSQLParser.CHECKPOINT, 0) + + def CLASS(self): + return self.getToken(PLpgSQLParser.CLASS, 0) + + def CLOSE(self): + return self.getToken(PLpgSQLParser.CLOSE, 0) + + def CLUSTER(self): + return self.getToken(PLpgSQLParser.CLUSTER, 0) + + def COLUMNS(self): + return self.getToken(PLpgSQLParser.COLUMNS, 0) + + def COMMENT(self): + return self.getToken(PLpgSQLParser.COMMENT, 0) + + def COMMENTS(self): + return self.getToken(PLpgSQLParser.COMMENTS, 0) + + def COMMIT(self): + return self.getToken(PLpgSQLParser.COMMIT, 0) + + def COMMITTED(self): + return self.getToken(PLpgSQLParser.COMMITTED, 0) + + def CONFIGURATION(self): + return self.getToken(PLpgSQLParser.CONFIGURATION, 0) + + def CONFLICT(self): + return self.getToken(PLpgSQLParser.CONFLICT, 0) + + def CONNECTION(self): + return self.getToken(PLpgSQLParser.CONNECTION, 0) + + def CONSTRAINTS(self): + return self.getToken(PLpgSQLParser.CONSTRAINTS, 0) + + def CONTENT(self): + return self.getToken(PLpgSQLParser.CONTENT, 0) + + def CONTINUE(self): + return self.getToken(PLpgSQLParser.CONTINUE, 0) + + def CONVERSION(self): + return self.getToken(PLpgSQLParser.CONVERSION, 0) + + def COPY(self): + return self.getToken(PLpgSQLParser.COPY, 0) + + def COST(self): + return self.getToken(PLpgSQLParser.COST, 0) + + def CSV(self): + return self.getToken(PLpgSQLParser.CSV, 0) + + def CUBE(self): + return self.getToken(PLpgSQLParser.CUBE, 0) + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def CURSOR(self): + return self.getToken(PLpgSQLParser.CURSOR, 0) + + def CYCLE(self): + return self.getToken(PLpgSQLParser.CYCLE, 0) + + def DATA(self): + return self.getToken(PLpgSQLParser.DATA, 0) + + def DATABASE(self): + return self.getToken(PLpgSQLParser.DATABASE, 0) + + def DAY(self): + return self.getToken(PLpgSQLParser.DAY, 0) + + def DEALLOCATE(self): + return self.getToken(PLpgSQLParser.DEALLOCATE, 0) + + def DECLARE(self): + return self.getToken(PLpgSQLParser.DECLARE, 0) + + def DEFAULTS(self): + return self.getToken(PLpgSQLParser.DEFAULTS, 0) + + def DEFERRED(self): + return self.getToken(PLpgSQLParser.DEFERRED, 0) + + def DEFINER(self): + return self.getToken(PLpgSQLParser.DEFINER, 0) + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def DELIMITER(self): + return self.getToken(PLpgSQLParser.DELIMITER, 0) + + def DELIMITERS(self): + return self.getToken(PLpgSQLParser.DELIMITERS, 0) + + def DEPENDS(self): + return self.getToken(PLpgSQLParser.DEPENDS, 0) + + def DETACH(self): + return self.getToken(PLpgSQLParser.DETACH, 0) + + def DICTIONARY(self): + return self.getToken(PLpgSQLParser.DICTIONARY, 0) + + def DISABLE(self): + return self.getToken(PLpgSQLParser.DISABLE, 0) + + def DISCARD(self): + return self.getToken(PLpgSQLParser.DISCARD, 0) + + def DOCUMENT(self): + return self.getToken(PLpgSQLParser.DOCUMENT, 0) + + def DOMAIN(self): + return self.getToken(PLpgSQLParser.DOMAIN, 0) + + def DOUBLE(self): + return self.getToken(PLpgSQLParser.DOUBLE, 0) + + def DROP(self): + return self.getToken(PLpgSQLParser.DROP, 0) + + def EACH(self): + return self.getToken(PLpgSQLParser.EACH, 0) + + def ENABLE(self): + return self.getToken(PLpgSQLParser.ENABLE, 0) + + def ENCODING(self): + return self.getToken(PLpgSQLParser.ENCODING, 0) + + def ENCRYPTED(self): + return self.getToken(PLpgSQLParser.ENCRYPTED, 0) + + def ENUM(self): + return self.getToken(PLpgSQLParser.ENUM, 0) + + def ESCAPE(self): + return self.getToken(PLpgSQLParser.ESCAPE, 0) + + def EVENT(self): + return self.getToken(PLpgSQLParser.EVENT, 0) + + def EXCLUDE(self): + return self.getToken(PLpgSQLParser.EXCLUDE, 0) + + def EXCLUDING(self): + return self.getToken(PLpgSQLParser.EXCLUDING, 0) + + def EXCLUSIVE(self): + return self.getToken(PLpgSQLParser.EXCLUSIVE, 0) + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def EXPLAIN(self): + return self.getToken(PLpgSQLParser.EXPLAIN, 0) + + def EXTENSION(self): + return self.getToken(PLpgSQLParser.EXTENSION, 0) + + def EXTERNAL(self): + return self.getToken(PLpgSQLParser.EXTERNAL, 0) + + def FAMILY(self): + return self.getToken(PLpgSQLParser.FAMILY, 0) + + def FILTER(self): + return self.getToken(PLpgSQLParser.FILTER, 0) + + def FIRST(self): + return self.getToken(PLpgSQLParser.FIRST, 0) + + def FOLLOWING(self): + return self.getToken(PLpgSQLParser.FOLLOWING, 0) + + def FORCE(self): + return self.getToken(PLpgSQLParser.FORCE, 0) + + def FORWARD(self): + return self.getToken(PLpgSQLParser.FORWARD, 0) + + def FUNCTION(self): + return self.getToken(PLpgSQLParser.FUNCTION, 0) + + def FUNCTIONS(self): + return self.getToken(PLpgSQLParser.FUNCTIONS, 0) + + def GENERATED(self): + return self.getToken(PLpgSQLParser.GENERATED, 0) + + def GLOBAL(self): + return self.getToken(PLpgSQLParser.GLOBAL, 0) + + def GRANTED(self): + return self.getToken(PLpgSQLParser.GRANTED, 0) + + def GROUPS(self): + return self.getToken(PLpgSQLParser.GROUPS, 0) + + def HANDLER(self): + return self.getToken(PLpgSQLParser.HANDLER, 0) + + def HEADER(self): + return self.getToken(PLpgSQLParser.HEADER, 0) + + def HOLD(self): + return self.getToken(PLpgSQLParser.HOLD, 0) + + def HOUR(self): + return self.getToken(PLpgSQLParser.HOUR, 0) + + def IDENTITY(self): + return self.getToken(PLpgSQLParser.IDENTITY, 0) + + def IF(self): + return self.getToken(PLpgSQLParser.IF, 0) + + def IMMEDIATE(self): + return self.getToken(PLpgSQLParser.IMMEDIATE, 0) + + def IMMUTABLE(self): + return self.getToken(PLpgSQLParser.IMMUTABLE, 0) + + def IMPLICIT(self): + return self.getToken(PLpgSQLParser.IMPLICIT, 0) + + def IMPORT(self): + return self.getToken(PLpgSQLParser.IMPORT, 0) + + def INCLUDE(self): + return self.getToken(PLpgSQLParser.INCLUDE, 0) + + def INCLUDING(self): + return self.getToken(PLpgSQLParser.INCLUDING, 0) + + def INCREMENT(self): + return self.getToken(PLpgSQLParser.INCREMENT, 0) + + def INDEX(self): + return self.getToken(PLpgSQLParser.INDEX, 0) + + def INDEXES(self): + return self.getToken(PLpgSQLParser.INDEXES, 0) + + def INHERIT(self): + return self.getToken(PLpgSQLParser.INHERIT, 0) + + def INHERITS(self): + return self.getToken(PLpgSQLParser.INHERITS, 0) + + def INLINE(self): + return self.getToken(PLpgSQLParser.INLINE, 0) + + def INPUT(self): + return self.getToken(PLpgSQLParser.INPUT, 0) + + def INSENSITIVE(self): + return self.getToken(PLpgSQLParser.INSENSITIVE, 0) + + def INSERT(self): + return self.getToken(PLpgSQLParser.INSERT, 0) + + def INSTEAD(self): + return self.getToken(PLpgSQLParser.INSTEAD, 0) + + def INVOKER(self): + return self.getToken(PLpgSQLParser.INVOKER, 0) + + def ISOLATION(self): + return self.getToken(PLpgSQLParser.ISOLATION, 0) + + def KEY(self): + return self.getToken(PLpgSQLParser.KEY, 0) + + def LABEL(self): + return self.getToken(PLpgSQLParser.LABEL, 0) + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def LARGE(self): + return self.getToken(PLpgSQLParser.LARGE, 0) + + def LAST(self): + return self.getToken(PLpgSQLParser.LAST, 0) + + def LEAKPROOF(self): + return self.getToken(PLpgSQLParser.LEAKPROOF, 0) + + def LEVEL(self): + return self.getToken(PLpgSQLParser.LEVEL, 0) + + def LISTEN(self): + return self.getToken(PLpgSQLParser.LISTEN, 0) + + def LOAD(self): + return self.getToken(PLpgSQLParser.LOAD, 0) + + def LOCAL(self): + return self.getToken(PLpgSQLParser.LOCAL, 0) + + def LOCATION(self): + return self.getToken(PLpgSQLParser.LOCATION, 0) + + def LOCK(self): + return self.getToken(PLpgSQLParser.LOCK, 0) + + def LOCKED(self): + return self.getToken(PLpgSQLParser.LOCKED, 0) + + def LOGGED(self): + return self.getToken(PLpgSQLParser.LOGGED, 0) + + def MAPPING(self): + return self.getToken(PLpgSQLParser.MAPPING, 0) + + def MATCH(self): + return self.getToken(PLpgSQLParser.MATCH, 0) + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def MAXVALUE(self): + return self.getToken(PLpgSQLParser.MAXVALUE, 0) + + def METHOD(self): + return self.getToken(PLpgSQLParser.METHOD, 0) + + def MINUTE(self): + return self.getToken(PLpgSQLParser.MINUTE, 0) + + def MINVALUE(self): + return self.getToken(PLpgSQLParser.MINVALUE, 0) + + def MODE(self): + return self.getToken(PLpgSQLParser.MODE, 0) + + def MONTH(self): + return self.getToken(PLpgSQLParser.MONTH, 0) + + def MOVE(self): + return self.getToken(PLpgSQLParser.MOVE, 0) + + def NAME(self): + return self.getToken(PLpgSQLParser.NAME, 0) + + def NAMES(self): + return self.getToken(PLpgSQLParser.NAMES, 0) + + def NEW(self): + return self.getToken(PLpgSQLParser.NEW, 0) + + def NEXT(self): + return self.getToken(PLpgSQLParser.NEXT, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def NOTHING(self): + return self.getToken(PLpgSQLParser.NOTHING, 0) + + def NOTIFY(self): + return self.getToken(PLpgSQLParser.NOTIFY, 0) + + def NOWAIT(self): + return self.getToken(PLpgSQLParser.NOWAIT, 0) + + def NULLS(self): + return self.getToken(PLpgSQLParser.NULLS, 0) + + def OBJECT(self): + return self.getToken(PLpgSQLParser.OBJECT, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def OFF(self): + return self.getToken(PLpgSQLParser.OFF, 0) + + def OIDS(self): + return self.getToken(PLpgSQLParser.OIDS, 0) + + def OLD(self): + return self.getToken(PLpgSQLParser.OLD, 0) + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def OPTION(self): + return self.getToken(PLpgSQLParser.OPTION, 0) + + def OPTIONS(self): + return self.getToken(PLpgSQLParser.OPTIONS, 0) + + def ORDINALITY(self): + return self.getToken(PLpgSQLParser.ORDINALITY, 0) + + def OTHERS(self): + return self.getToken(PLpgSQLParser.OTHERS, 0) + + def OVER(self): + return self.getToken(PLpgSQLParser.OVER, 0) + + def OVERRIDING(self): + return self.getToken(PLpgSQLParser.OVERRIDING, 0) + + def OWNED(self): + return self.getToken(PLpgSQLParser.OWNED, 0) + + def OWNER(self): + return self.getToken(PLpgSQLParser.OWNER, 0) + + def PARALLEL(self): + return self.getToken(PLpgSQLParser.PARALLEL, 0) + + def PARSER(self): + return self.getToken(PLpgSQLParser.PARSER, 0) + + def PARTIAL(self): + return self.getToken(PLpgSQLParser.PARTIAL, 0) + + def PARTITION(self): + return self.getToken(PLpgSQLParser.PARTITION, 0) + + def PASSING(self): + return self.getToken(PLpgSQLParser.PASSING, 0) + + def PASSWORD(self): + return self.getToken(PLpgSQLParser.PASSWORD, 0) + + def PLANS(self): + return self.getToken(PLpgSQLParser.PLANS, 0) + + def POLICY(self): + return self.getToken(PLpgSQLParser.POLICY, 0) + + def PRECEDING(self): + return self.getToken(PLpgSQLParser.PRECEDING, 0) + + def PREPARE(self): + return self.getToken(PLpgSQLParser.PREPARE, 0) + + def PREPARED(self): + return self.getToken(PLpgSQLParser.PREPARED, 0) + + def PRESERVE(self): + return self.getToken(PLpgSQLParser.PRESERVE, 0) + + def PRIOR(self): + return self.getToken(PLpgSQLParser.PRIOR, 0) + + def PRIVILEGES(self): + return self.getToken(PLpgSQLParser.PRIVILEGES, 0) + + def PROCEDURAL(self): + return self.getToken(PLpgSQLParser.PROCEDURAL, 0) + + def PROCEDURE(self): + return self.getToken(PLpgSQLParser.PROCEDURE, 0) + + def PROCEDURES(self): + return self.getToken(PLpgSQLParser.PROCEDURES, 0) + + def PROGRAM(self): + return self.getToken(PLpgSQLParser.PROGRAM, 0) + + def PUBLICATION(self): + return self.getToken(PLpgSQLParser.PUBLICATION, 0) + + def QUOTE(self): + return self.getToken(PLpgSQLParser.QUOTE, 0) + + def RANGE(self): + return self.getToken(PLpgSQLParser.RANGE, 0) + + def READ(self): + return self.getToken(PLpgSQLParser.READ, 0) + + def REASSIGN(self): + return self.getToken(PLpgSQLParser.REASSIGN, 0) + + def RECHECK(self): + return self.getToken(PLpgSQLParser.RECHECK, 0) + + def RECURSIVE(self): + return self.getToken(PLpgSQLParser.RECURSIVE, 0) + + def REF(self): + return self.getToken(PLpgSQLParser.REF, 0) + + def REFERENCING(self): + return self.getToken(PLpgSQLParser.REFERENCING, 0) + + def REFRESH(self): + return self.getToken(PLpgSQLParser.REFRESH, 0) + + def REINDEX(self): + return self.getToken(PLpgSQLParser.REINDEX, 0) + + def RELATIVE(self): + return self.getToken(PLpgSQLParser.RELATIVE, 0) + + def RELEASE(self): + return self.getToken(PLpgSQLParser.RELEASE, 0) + + def RENAME(self): + return self.getToken(PLpgSQLParser.RENAME, 0) + + def REPEATABLE(self): + return self.getToken(PLpgSQLParser.REPEATABLE, 0) + + def REPLACE(self): + return self.getToken(PLpgSQLParser.REPLACE, 0) + + def REPLICA(self): + return self.getToken(PLpgSQLParser.REPLICA, 0) + + def RESET(self): + return self.getToken(PLpgSQLParser.RESET, 0) + + def RESTART(self): + return self.getToken(PLpgSQLParser.RESTART, 0) + + def RESTRICT(self): + return self.getToken(PLpgSQLParser.RESTRICT, 0) + + def RETURNS(self): + return self.getToken(PLpgSQLParser.RETURNS, 0) + + def REVOKE(self): + return self.getToken(PLpgSQLParser.REVOKE, 0) + + def ROLE(self): + return self.getToken(PLpgSQLParser.ROLE, 0) + + def ROLLBACK(self): + return self.getToken(PLpgSQLParser.ROLLBACK, 0) + + def ROLLUP(self): + return self.getToken(PLpgSQLParser.ROLLUP, 0) + + def ROUTINE(self): + return self.getToken(PLpgSQLParser.ROUTINE, 0) + + def ROUTINES(self): + return self.getToken(PLpgSQLParser.ROUTINES, 0) + + def ROWS(self): + return self.getToken(PLpgSQLParser.ROWS, 0) + + def RULE(self): + return self.getToken(PLpgSQLParser.RULE, 0) + + def SAVEPOINT(self): + return self.getToken(PLpgSQLParser.SAVEPOINT, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def SCHEMAS(self): + return self.getToken(PLpgSQLParser.SCHEMAS, 0) + + def SCROLL(self): + return self.getToken(PLpgSQLParser.SCROLL, 0) + + def SEARCH(self): + return self.getToken(PLpgSQLParser.SEARCH, 0) + + def SECOND(self): + return self.getToken(PLpgSQLParser.SECOND, 0) + + def SECURITY(self): + return self.getToken(PLpgSQLParser.SECURITY, 0) + + def SEQUENCE(self): + return self.getToken(PLpgSQLParser.SEQUENCE, 0) + + def SEQUENCES(self): + return self.getToken(PLpgSQLParser.SEQUENCES, 0) + + def SERIALIZABLE(self): + return self.getToken(PLpgSQLParser.SERIALIZABLE, 0) + + def SERVER(self): + return self.getToken(PLpgSQLParser.SERVER, 0) + + def SESSION(self): + return self.getToken(PLpgSQLParser.SESSION, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def SETS(self): + return self.getToken(PLpgSQLParser.SETS, 0) + + def SHARE(self): + return self.getToken(PLpgSQLParser.SHARE, 0) + + def SHOW(self): + return self.getToken(PLpgSQLParser.SHOW, 0) + + def SIMPLE(self): + return self.getToken(PLpgSQLParser.SIMPLE, 0) + + def SKIP_(self): + return self.getToken(PLpgSQLParser.SKIP_, 0) + + def SNAPSHOT(self): + return self.getToken(PLpgSQLParser.SNAPSHOT, 0) + + def SQL(self): + return self.getToken(PLpgSQLParser.SQL, 0) + + def STABLE(self): + return self.getToken(PLpgSQLParser.STABLE, 0) + + def STANDALONE(self): + return self.getToken(PLpgSQLParser.STANDALONE, 0) + + def START(self): + return self.getToken(PLpgSQLParser.START, 0) + + def STATEMENT(self): + return self.getToken(PLpgSQLParser.STATEMENT, 0) + + def STATISTICS(self): + return self.getToken(PLpgSQLParser.STATISTICS, 0) + + def STDIN(self): + return self.getToken(PLpgSQLParser.STDIN, 0) + + def STDOUT(self): + return self.getToken(PLpgSQLParser.STDOUT, 0) + + def STORAGE(self): + return self.getToken(PLpgSQLParser.STORAGE, 0) + + def STORED(self): + return self.getToken(PLpgSQLParser.STORED, 0) + + def STRICT(self): + return self.getToken(PLpgSQLParser.STRICT, 0) + + def STRIP(self): + return self.getToken(PLpgSQLParser.STRIP, 0) + + def SUBSCRIPTION(self): + return self.getToken(PLpgSQLParser.SUBSCRIPTION, 0) + + def SUPPORT(self): + return self.getToken(PLpgSQLParser.SUPPORT, 0) + + def SYSID(self): + return self.getToken(PLpgSQLParser.SYSID, 0) + + def SYSTEM(self): + return self.getToken(PLpgSQLParser.SYSTEM, 0) + + def TABLES(self): + return self.getToken(PLpgSQLParser.TABLES, 0) + + def TABLESPACE(self): + return self.getToken(PLpgSQLParser.TABLESPACE, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def TEMPLATE(self): + return self.getToken(PLpgSQLParser.TEMPLATE, 0) + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def TEXT(self): + return self.getToken(PLpgSQLParser.TEXT, 0) + + def TIES(self): + return self.getToken(PLpgSQLParser.TIES, 0) + + def TRANSACTION(self): + return self.getToken(PLpgSQLParser.TRANSACTION, 0) + + def TRANSFORM(self): + return self.getToken(PLpgSQLParser.TRANSFORM, 0) + + def TRIGGER(self): + return self.getToken(PLpgSQLParser.TRIGGER, 0) + + def TRUNCATE(self): + return self.getToken(PLpgSQLParser.TRUNCATE, 0) + + def TRUSTED(self): + return self.getToken(PLpgSQLParser.TRUSTED, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def TYPES(self): + return self.getToken(PLpgSQLParser.TYPES, 0) + + def UNBOUNDED(self): + return self.getToken(PLpgSQLParser.UNBOUNDED, 0) + + def UNCOMMITTED(self): + return self.getToken(PLpgSQLParser.UNCOMMITTED, 0) + + def UNENCRYPTED(self): + return self.getToken(PLpgSQLParser.UNENCRYPTED, 0) + + def UNKNOWN(self): + return self.getToken(PLpgSQLParser.UNKNOWN, 0) + + def UNLISTEN(self): + return self.getToken(PLpgSQLParser.UNLISTEN, 0) + + def UNLOGGED(self): + return self.getToken(PLpgSQLParser.UNLOGGED, 0) + + def UNTIL(self): + return self.getToken(PLpgSQLParser.UNTIL, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def VACUUM(self): + return self.getToken(PLpgSQLParser.VACUUM, 0) + + def VALID(self): + return self.getToken(PLpgSQLParser.VALID, 0) + + def VALIDATE(self): + return self.getToken(PLpgSQLParser.VALIDATE, 0) + + def VALIDATOR(self): + return self.getToken(PLpgSQLParser.VALIDATOR, 0) + + def VALUE(self): + return self.getToken(PLpgSQLParser.VALUE, 0) + + def VARYING(self): + return self.getToken(PLpgSQLParser.VARYING, 0) + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def VIEW(self): + return self.getToken(PLpgSQLParser.VIEW, 0) + + def VIEWS(self): + return self.getToken(PLpgSQLParser.VIEWS, 0) + + def VOLATILE(self): + return self.getToken(PLpgSQLParser.VOLATILE, 0) + + def WHITESPACE(self): + return self.getToken(PLpgSQLParser.WHITESPACE, 0) + + def WITHIN(self): + return self.getToken(PLpgSQLParser.WITHIN, 0) + + def WITHOUT(self): + return self.getToken(PLpgSQLParser.WITHOUT, 0) + + def WORK(self): + return self.getToken(PLpgSQLParser.WORK, 0) + + def WRAPPER(self): + return self.getToken(PLpgSQLParser.WRAPPER, 0) + + def WRITE(self): + return self.getToken(PLpgSQLParser.WRITE, 0) + + def XML(self): + return self.getToken(PLpgSQLParser.XML, 0) + + def YEAR(self): + return self.getToken(PLpgSQLParser.YEAR, 0) + + def YES(self): + return self.getToken(PLpgSQLParser.YES, 0) + + def ZONE(self): + return self.getToken(PLpgSQLParser.ZONE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_tokens_nonreserved + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTokens_nonreserved" ): + listener.enterTokens_nonreserved(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTokens_nonreserved" ): + listener.exitTokens_nonreserved(self) + + + + + def tokens_nonreserved(self): + + localctx = PLpgSQLParser.Tokens_nonreservedContext(self, self._ctx, self.state) + self.enterRule(localctx, 532, self.RULE_tokens_nonreserved) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5340 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Tokens_nonreserved_except_function_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BETWEEN(self): + return self.getToken(PLpgSQLParser.BETWEEN, 0) + + def BIGINT(self): + return self.getToken(PLpgSQLParser.BIGINT, 0) + + def BIT(self): + return self.getToken(PLpgSQLParser.BIT, 0) + + def BOOLEAN(self): + return self.getToken(PLpgSQLParser.BOOLEAN, 0) + + def CHAR(self): + return self.getToken(PLpgSQLParser.CHAR, 0) + + def CHARACTER(self): + return self.getToken(PLpgSQLParser.CHARACTER, 0) + + def COALESCE(self): + return self.getToken(PLpgSQLParser.COALESCE, 0) + + def DEC(self): + return self.getToken(PLpgSQLParser.DEC, 0) + + def DECIMAL(self): + return self.getToken(PLpgSQLParser.DECIMAL, 0) + + def EXISTS(self): + return self.getToken(PLpgSQLParser.EXISTS, 0) + + def EXTRACT(self): + return self.getToken(PLpgSQLParser.EXTRACT, 0) + + def FLOAT(self): + return self.getToken(PLpgSQLParser.FLOAT, 0) + + def GREATEST(self): + return self.getToken(PLpgSQLParser.GREATEST, 0) + + def GROUPING(self): + return self.getToken(PLpgSQLParser.GROUPING, 0) + + def INOUT(self): + return self.getToken(PLpgSQLParser.INOUT, 0) + + def INT(self): + return self.getToken(PLpgSQLParser.INT, 0) + + def INTEGER(self): + return self.getToken(PLpgSQLParser.INTEGER, 0) + + def INTERVAL(self): + return self.getToken(PLpgSQLParser.INTERVAL, 0) + + def LEAST(self): + return self.getToken(PLpgSQLParser.LEAST, 0) + + def NATIONAL(self): + return self.getToken(PLpgSQLParser.NATIONAL, 0) + + def NCHAR(self): + return self.getToken(PLpgSQLParser.NCHAR, 0) + + def NONE(self): + return self.getToken(PLpgSQLParser.NONE, 0) + + def NULLIF(self): + return self.getToken(PLpgSQLParser.NULLIF, 0) + + def NUMERIC(self): + return self.getToken(PLpgSQLParser.NUMERIC, 0) + + def OUT(self): + return self.getToken(PLpgSQLParser.OUT, 0) + + def OVERLAY(self): + return self.getToken(PLpgSQLParser.OVERLAY, 0) + + def POSITION(self): + return self.getToken(PLpgSQLParser.POSITION, 0) + + def PRECISION(self): + return self.getToken(PLpgSQLParser.PRECISION, 0) + + def REAL(self): + return self.getToken(PLpgSQLParser.REAL, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def SETOF(self): + return self.getToken(PLpgSQLParser.SETOF, 0) + + def SMALLINT(self): + return self.getToken(PLpgSQLParser.SMALLINT, 0) + + def SUBSTRING(self): + return self.getToken(PLpgSQLParser.SUBSTRING, 0) + + def TIME(self): + return self.getToken(PLpgSQLParser.TIME, 0) + + def TIMESTAMP(self): + return self.getToken(PLpgSQLParser.TIMESTAMP, 0) + + def TREAT(self): + return self.getToken(PLpgSQLParser.TREAT, 0) + + def TRIM(self): + return self.getToken(PLpgSQLParser.TRIM, 0) + + def VALUES(self): + return self.getToken(PLpgSQLParser.VALUES, 0) + + def VARCHAR(self): + return self.getToken(PLpgSQLParser.VARCHAR, 0) + + def XMLATTRIBUTES(self): + return self.getToken(PLpgSQLParser.XMLATTRIBUTES, 0) + + def XMLCONCAT(self): + return self.getToken(PLpgSQLParser.XMLCONCAT, 0) + + def XMLELEMENT(self): + return self.getToken(PLpgSQLParser.XMLELEMENT, 0) + + def XMLEXISTS(self): + return self.getToken(PLpgSQLParser.XMLEXISTS, 0) + + def XMLFOREST(self): + return self.getToken(PLpgSQLParser.XMLFOREST, 0) + + def XMLNAMESPACES(self): + return self.getToken(PLpgSQLParser.XMLNAMESPACES, 0) + + def XMLPARSE(self): + return self.getToken(PLpgSQLParser.XMLPARSE, 0) + + def XMLPI(self): + return self.getToken(PLpgSQLParser.XMLPI, 0) + + def XMLROOT(self): + return self.getToken(PLpgSQLParser.XMLROOT, 0) + + def XMLSERIALIZE(self): + return self.getToken(PLpgSQLParser.XMLSERIALIZE, 0) + + def XMLTABLE(self): + return self.getToken(PLpgSQLParser.XMLTABLE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_tokens_nonreserved_except_function_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTokens_nonreserved_except_function_type" ): + listener.enterTokens_nonreserved_except_function_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTokens_nonreserved_except_function_type" ): + listener.exitTokens_nonreserved_except_function_type(self) + + + + + def tokens_nonreserved_except_function_type(self): + + localctx = PLpgSQLParser.Tokens_nonreserved_except_function_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 534, self.RULE_tokens_nonreserved_except_function_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5342 + _la = self._input.LA(1) + if not(((((_la - 293)) & ~0x3f) == 0 and ((1 << (_la - 293)) & ((1 << (PLpgSQLParser.BETWEEN - 293)) | (1 << (PLpgSQLParser.BIGINT - 293)) | (1 << (PLpgSQLParser.BIT - 293)) | (1 << (PLpgSQLParser.BOOLEAN - 293)) | (1 << (PLpgSQLParser.CHAR - 293)) | (1 << (PLpgSQLParser.CHARACTER - 293)) | (1 << (PLpgSQLParser.COALESCE - 293)) | (1 << (PLpgSQLParser.DEC - 293)) | (1 << (PLpgSQLParser.DECIMAL - 293)) | (1 << (PLpgSQLParser.EXISTS - 293)) | (1 << (PLpgSQLParser.EXTRACT - 293)) | (1 << (PLpgSQLParser.FLOAT - 293)) | (1 << (PLpgSQLParser.GREATEST - 293)) | (1 << (PLpgSQLParser.GROUPING - 293)) | (1 << (PLpgSQLParser.INOUT - 293)) | (1 << (PLpgSQLParser.INT - 293)) | (1 << (PLpgSQLParser.INTEGER - 293)) | (1 << (PLpgSQLParser.INTERVAL - 293)) | (1 << (PLpgSQLParser.LEAST - 293)) | (1 << (PLpgSQLParser.NATIONAL - 293)) | (1 << (PLpgSQLParser.NCHAR - 293)) | (1 << (PLpgSQLParser.NONE - 293)) | (1 << (PLpgSQLParser.NULLIF - 293)) | (1 << (PLpgSQLParser.NUMERIC - 293)) | (1 << (PLpgSQLParser.OUT - 293)) | (1 << (PLpgSQLParser.OVERLAY - 293)) | (1 << (PLpgSQLParser.POSITION - 293)) | (1 << (PLpgSQLParser.PRECISION - 293)) | (1 << (PLpgSQLParser.REAL - 293)) | (1 << (PLpgSQLParser.ROW - 293)) | (1 << (PLpgSQLParser.SETOF - 293)) | (1 << (PLpgSQLParser.SMALLINT - 293)) | (1 << (PLpgSQLParser.SUBSTRING - 293)) | (1 << (PLpgSQLParser.TIME - 293)) | (1 << (PLpgSQLParser.TIMESTAMP - 293)) | (1 << (PLpgSQLParser.TREAT - 293)) | (1 << (PLpgSQLParser.TRIM - 293)) | (1 << (PLpgSQLParser.VALUES - 293)) | (1 << (PLpgSQLParser.VARCHAR - 293)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 293)) | (1 << (PLpgSQLParser.XMLCONCAT - 293)) | (1 << (PLpgSQLParser.XMLELEMENT - 293)) | (1 << (PLpgSQLParser.XMLEXISTS - 293)) | (1 << (PLpgSQLParser.XMLFOREST - 293)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 293)) | (1 << (PLpgSQLParser.XMLPARSE - 293)) | (1 << (PLpgSQLParser.XMLPI - 293)) | (1 << (PLpgSQLParser.XMLROOT - 293)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 293)) | (1 << (PLpgSQLParser.XMLTABLE - 293)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Tokens_reserved_except_function_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AUTHORIZATION(self): + return self.getToken(PLpgSQLParser.AUTHORIZATION, 0) + + def BINARY(self): + return self.getToken(PLpgSQLParser.BINARY, 0) + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def CONCURRENTLY(self): + return self.getToken(PLpgSQLParser.CONCURRENTLY, 0) + + def CROSS(self): + return self.getToken(PLpgSQLParser.CROSS, 0) + + def CURRENT_SCHEMA(self): + return self.getToken(PLpgSQLParser.CURRENT_SCHEMA, 0) + + def FREEZE(self): + return self.getToken(PLpgSQLParser.FREEZE, 0) + + def FULL(self): + return self.getToken(PLpgSQLParser.FULL, 0) + + def ILIKE(self): + return self.getToken(PLpgSQLParser.ILIKE, 0) + + def INNER(self): + return self.getToken(PLpgSQLParser.INNER, 0) + + def IS(self): + return self.getToken(PLpgSQLParser.IS, 0) + + def ISNULL(self): + return self.getToken(PLpgSQLParser.ISNULL, 0) + + def JOIN(self): + return self.getToken(PLpgSQLParser.JOIN, 0) + + def LEFT(self): + return self.getToken(PLpgSQLParser.LEFT, 0) + + def LIKE(self): + return self.getToken(PLpgSQLParser.LIKE, 0) + + def NATURAL(self): + return self.getToken(PLpgSQLParser.NATURAL, 0) + + def NOTNULL(self): + return self.getToken(PLpgSQLParser.NOTNULL, 0) + + def OUTER(self): + return self.getToken(PLpgSQLParser.OUTER, 0) + + def OVERLAPS(self): + return self.getToken(PLpgSQLParser.OVERLAPS, 0) + + def RIGHT(self): + return self.getToken(PLpgSQLParser.RIGHT, 0) + + def SIMILAR(self): + return self.getToken(PLpgSQLParser.SIMILAR, 0) + + def TABLESAMPLE(self): + return self.getToken(PLpgSQLParser.TABLESAMPLE, 0) + + def VERBOSE(self): + return self.getToken(PLpgSQLParser.VERBOSE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_tokens_reserved_except_function_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTokens_reserved_except_function_type" ): + listener.enterTokens_reserved_except_function_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTokens_reserved_except_function_type" ): + listener.exitTokens_reserved_except_function_type(self) + + + + + def tokens_reserved_except_function_type(self): + + localctx = PLpgSQLParser.Tokens_reserved_except_function_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 536, self.RULE_tokens_reserved_except_function_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5344 + _la = self._input.LA(1) + if not(((((_la - 343)) & ~0x3f) == 0 and ((1 << (_la - 343)) & ((1 << (PLpgSQLParser.AUTHORIZATION - 343)) | (1 << (PLpgSQLParser.BINARY - 343)) | (1 << (PLpgSQLParser.COLLATION - 343)) | (1 << (PLpgSQLParser.CONCURRENTLY - 343)) | (1 << (PLpgSQLParser.CROSS - 343)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 343)) | (1 << (PLpgSQLParser.FREEZE - 343)) | (1 << (PLpgSQLParser.FULL - 343)) | (1 << (PLpgSQLParser.ILIKE - 343)) | (1 << (PLpgSQLParser.INNER - 343)) | (1 << (PLpgSQLParser.IS - 343)) | (1 << (PLpgSQLParser.ISNULL - 343)) | (1 << (PLpgSQLParser.JOIN - 343)) | (1 << (PLpgSQLParser.LEFT - 343)) | (1 << (PLpgSQLParser.LIKE - 343)) | (1 << (PLpgSQLParser.NATURAL - 343)) | (1 << (PLpgSQLParser.NOTNULL - 343)) | (1 << (PLpgSQLParser.OUTER - 343)) | (1 << (PLpgSQLParser.OVERLAPS - 343)) | (1 << (PLpgSQLParser.RIGHT - 343)) | (1 << (PLpgSQLParser.SIMILAR - 343)) | (1 << (PLpgSQLParser.TABLESAMPLE - 343)) | (1 << (PLpgSQLParser.VERBOSE - 343)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Tokens_reservedContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def ANALYSE(self): + return self.getToken(PLpgSQLParser.ANALYSE, 0) + + def ANALYZE(self): + return self.getToken(PLpgSQLParser.ANALYZE, 0) + + def AND(self): + return self.getToken(PLpgSQLParser.AND, 0) + + def ANY(self): + return self.getToken(PLpgSQLParser.ANY, 0) + + def ARRAY(self): + return self.getToken(PLpgSQLParser.ARRAY, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def ASC(self): + return self.getToken(PLpgSQLParser.ASC, 0) + + def ASYMMETRIC(self): + return self.getToken(PLpgSQLParser.ASYMMETRIC, 0) + + def BOTH(self): + return self.getToken(PLpgSQLParser.BOTH, 0) + + def CASE(self): + return self.getToken(PLpgSQLParser.CASE, 0) + + def CAST(self): + return self.getToken(PLpgSQLParser.CAST, 0) + + def CHECK(self): + return self.getToken(PLpgSQLParser.CHECK, 0) + + def COLLATE(self): + return self.getToken(PLpgSQLParser.COLLATE, 0) + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def CREATE(self): + return self.getToken(PLpgSQLParser.CREATE, 0) + + def CURRENT_CATALOG(self): + return self.getToken(PLpgSQLParser.CURRENT_CATALOG, 0) + + def CURRENT_DATE(self): + return self.getToken(PLpgSQLParser.CURRENT_DATE, 0) + + def CURRENT_ROLE(self): + return self.getToken(PLpgSQLParser.CURRENT_ROLE, 0) + + def CURRENT_TIME(self): + return self.getToken(PLpgSQLParser.CURRENT_TIME, 0) + + def CURRENT_TIMESTAMP(self): + return self.getToken(PLpgSQLParser.CURRENT_TIMESTAMP, 0) + + def CURRENT_USER(self): + return self.getToken(PLpgSQLParser.CURRENT_USER, 0) + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def DEFERRABLE(self): + return self.getToken(PLpgSQLParser.DEFERRABLE, 0) + + def DESC(self): + return self.getToken(PLpgSQLParser.DESC, 0) + + def DISTINCT(self): + return self.getToken(PLpgSQLParser.DISTINCT, 0) + + def DO(self): + return self.getToken(PLpgSQLParser.DO, 0) + + def ELSE(self): + return self.getToken(PLpgSQLParser.ELSE, 0) + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def EXCEPT(self): + return self.getToken(PLpgSQLParser.EXCEPT, 0) + + def FALSE(self): + return self.getToken(PLpgSQLParser.FALSE, 0) + + def FETCH(self): + return self.getToken(PLpgSQLParser.FETCH, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def FOREIGN(self): + return self.getToken(PLpgSQLParser.FOREIGN, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def GRANT(self): + return self.getToken(PLpgSQLParser.GRANT, 0) + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def HAVING(self): + return self.getToken(PLpgSQLParser.HAVING, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def INITIALLY(self): + return self.getToken(PLpgSQLParser.INITIALLY, 0) + + def INTERSECT(self): + return self.getToken(PLpgSQLParser.INTERSECT, 0) + + def INTO(self): + return self.getToken(PLpgSQLParser.INTO, 0) + + def LATERAL(self): + return self.getToken(PLpgSQLParser.LATERAL, 0) + + def LEADING(self): + return self.getToken(PLpgSQLParser.LEADING, 0) + + def LIMIT(self): + return self.getToken(PLpgSQLParser.LIMIT, 0) + + def LOCALTIME(self): + return self.getToken(PLpgSQLParser.LOCALTIME, 0) + + def LOCALTIMESTAMP(self): + return self.getToken(PLpgSQLParser.LOCALTIMESTAMP, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def OFFSET(self): + return self.getToken(PLpgSQLParser.OFFSET, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def ORDER(self): + return self.getToken(PLpgSQLParser.ORDER, 0) + + def PLACING(self): + return self.getToken(PLpgSQLParser.PLACING, 0) + + def PRIMARY(self): + return self.getToken(PLpgSQLParser.PRIMARY, 0) + + def REFERENCES(self): + return self.getToken(PLpgSQLParser.REFERENCES, 0) + + def RETURNING(self): + return self.getToken(PLpgSQLParser.RETURNING, 0) + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def SESSION_USER(self): + return self.getToken(PLpgSQLParser.SESSION_USER, 0) + + def SOME(self): + return self.getToken(PLpgSQLParser.SOME, 0) + + def SYMMETRIC(self): + return self.getToken(PLpgSQLParser.SYMMETRIC, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def THEN(self): + return self.getToken(PLpgSQLParser.THEN, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def TRAILING(self): + return self.getToken(PLpgSQLParser.TRAILING, 0) + + def TRUE(self): + return self.getToken(PLpgSQLParser.TRUE, 0) + + def UNION(self): + return self.getToken(PLpgSQLParser.UNION, 0) + + def UNIQUE(self): + return self.getToken(PLpgSQLParser.UNIQUE, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def VARIADIC(self): + return self.getToken(PLpgSQLParser.VARIADIC, 0) + + def WHEN(self): + return self.getToken(PLpgSQLParser.WHEN, 0) + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def WINDOW(self): + return self.getToken(PLpgSQLParser.WINDOW, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_tokens_reserved + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTokens_reserved" ): + listener.enterTokens_reserved(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTokens_reserved" ): + listener.exitTokens_reserved(self) + + + + + def tokens_reserved(self): + + localctx = PLpgSQLParser.Tokens_reservedContext(self, self._ctx, self.state) + self.enterRule(localctx, 538, self.RULE_tokens_reserved) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5346 + _la = self._input.LA(1) + if not(((((_la - 366)) & ~0x3f) == 0 and ((1 << (_la - 366)) & ((1 << (PLpgSQLParser.ALL - 366)) | (1 << (PLpgSQLParser.ANALYSE - 366)) | (1 << (PLpgSQLParser.ANALYZE - 366)) | (1 << (PLpgSQLParser.AND - 366)) | (1 << (PLpgSQLParser.ANY - 366)) | (1 << (PLpgSQLParser.ARRAY - 366)) | (1 << (PLpgSQLParser.AS - 366)) | (1 << (PLpgSQLParser.ASC - 366)) | (1 << (PLpgSQLParser.ASYMMETRIC - 366)) | (1 << (PLpgSQLParser.BOTH - 366)) | (1 << (PLpgSQLParser.CASE - 366)) | (1 << (PLpgSQLParser.CAST - 366)) | (1 << (PLpgSQLParser.CHECK - 366)) | (1 << (PLpgSQLParser.COLLATE - 366)) | (1 << (PLpgSQLParser.COLUMN - 366)) | (1 << (PLpgSQLParser.CONSTRAINT - 366)) | (1 << (PLpgSQLParser.CREATE - 366)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 366)) | (1 << (PLpgSQLParser.CURRENT_DATE - 366)) | (1 << (PLpgSQLParser.CURRENT_ROLE - 366)) | (1 << (PLpgSQLParser.CURRENT_TIME - 366)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 366)) | (1 << (PLpgSQLParser.CURRENT_USER - 366)) | (1 << (PLpgSQLParser.DEFAULT - 366)) | (1 << (PLpgSQLParser.DEFERRABLE - 366)) | (1 << (PLpgSQLParser.DESC - 366)) | (1 << (PLpgSQLParser.DISTINCT - 366)) | (1 << (PLpgSQLParser.DO - 366)) | (1 << (PLpgSQLParser.ELSE - 366)) | (1 << (PLpgSQLParser.END - 366)) | (1 << (PLpgSQLParser.EXCEPT - 366)) | (1 << (PLpgSQLParser.FALSE - 366)) | (1 << (PLpgSQLParser.FETCH - 366)) | (1 << (PLpgSQLParser.FOR - 366)) | (1 << (PLpgSQLParser.FOREIGN - 366)) | (1 << (PLpgSQLParser.FROM - 366)) | (1 << (PLpgSQLParser.GRANT - 366)) | (1 << (PLpgSQLParser.GROUP - 366)) | (1 << (PLpgSQLParser.HAVING - 366)) | (1 << (PLpgSQLParser.IN - 366)) | (1 << (PLpgSQLParser.INITIALLY - 366)) | (1 << (PLpgSQLParser.INTERSECT - 366)) | (1 << (PLpgSQLParser.INTO - 366)) | (1 << (PLpgSQLParser.LATERAL - 366)) | (1 << (PLpgSQLParser.LEADING - 366)) | (1 << (PLpgSQLParser.LIMIT - 366)) | (1 << (PLpgSQLParser.LOCALTIME - 366)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 366)) | (1 << (PLpgSQLParser.NOT - 366)) | (1 << (PLpgSQLParser.NULL - 366)) | (1 << (PLpgSQLParser.OFFSET - 366)) | (1 << (PLpgSQLParser.ON - 366)) | (1 << (PLpgSQLParser.ONLY - 366)) | (1 << (PLpgSQLParser.OR - 366)) | (1 << (PLpgSQLParser.ORDER - 366)) | (1 << (PLpgSQLParser.PLACING - 366)) | (1 << (PLpgSQLParser.PRIMARY - 366)) | (1 << (PLpgSQLParser.REFERENCES - 366)) | (1 << (PLpgSQLParser.RETURNING - 366)) | (1 << (PLpgSQLParser.SELECT - 366)) | (1 << (PLpgSQLParser.SESSION_USER - 366)) | (1 << (PLpgSQLParser.SOME - 366)) | (1 << (PLpgSQLParser.SYMMETRIC - 366)) | (1 << (PLpgSQLParser.TABLE - 366)))) != 0) or ((((_la - 430)) & ~0x3f) == 0 and ((1 << (_la - 430)) & ((1 << (PLpgSQLParser.THEN - 430)) | (1 << (PLpgSQLParser.TO - 430)) | (1 << (PLpgSQLParser.TRAILING - 430)) | (1 << (PLpgSQLParser.TRUE - 430)) | (1 << (PLpgSQLParser.UNION - 430)) | (1 << (PLpgSQLParser.UNIQUE - 430)) | (1 << (PLpgSQLParser.USER - 430)) | (1 << (PLpgSQLParser.USING - 430)) | (1 << (PLpgSQLParser.VARIADIC - 430)) | (1 << (PLpgSQLParser.WHEN - 430)) | (1 << (PLpgSQLParser.WHERE - 430)) | (1 << (PLpgSQLParser.WINDOW - 430)) | (1 << (PLpgSQLParser.WITH - 430)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Tokens_nonkeywordContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALIGNMENT(self): + return self.getToken(PLpgSQLParser.ALIGNMENT, 0) + + def BASETYPE(self): + return self.getToken(PLpgSQLParser.BASETYPE, 0) + + def BUFFERS(self): + return self.getToken(PLpgSQLParser.BUFFERS, 0) + + def BYPASSRLS(self): + return self.getToken(PLpgSQLParser.BYPASSRLS, 0) + + def CANONICAL(self): + return self.getToken(PLpgSQLParser.CANONICAL, 0) + + def CATEGORY(self): + return self.getToken(PLpgSQLParser.CATEGORY, 0) + + def COLLATABLE(self): + return self.getToken(PLpgSQLParser.COLLATABLE, 0) + + def COMBINEFUNC(self): + return self.getToken(PLpgSQLParser.COMBINEFUNC, 0) + + def COMMUTATOR(self): + return self.getToken(PLpgSQLParser.COMMUTATOR, 0) + + def CONNECT(self): + return self.getToken(PLpgSQLParser.CONNECT, 0) + + def COSTS(self): + return self.getToken(PLpgSQLParser.COSTS, 0) + + def CREATEDB(self): + return self.getToken(PLpgSQLParser.CREATEDB, 0) + + def CREATEROLE(self): + return self.getToken(PLpgSQLParser.CREATEROLE, 0) + + def DESERIALFUNC(self): + return self.getToken(PLpgSQLParser.DESERIALFUNC, 0) + + def DETERMINISTIC(self): + return self.getToken(PLpgSQLParser.DETERMINISTIC, 0) + + def DISABLE_PAGE_SKIPPING(self): + return self.getToken(PLpgSQLParser.DISABLE_PAGE_SKIPPING, 0) + + def ELEMENT(self): + return self.getToken(PLpgSQLParser.ELEMENT, 0) + + def EXTENDED(self): + return self.getToken(PLpgSQLParser.EXTENDED, 0) + + def FINALFUNC(self): + return self.getToken(PLpgSQLParser.FINALFUNC, 0) + + def FINALFUNC_EXTRA(self): + return self.getToken(PLpgSQLParser.FINALFUNC_EXTRA, 0) + + def FINALFUNC_MODIFY(self): + return self.getToken(PLpgSQLParser.FINALFUNC_MODIFY, 0) + + def FORCE_NOT_NULL(self): + return self.getToken(PLpgSQLParser.FORCE_NOT_NULL, 0) + + def FORCE_NULL(self): + return self.getToken(PLpgSQLParser.FORCE_NULL, 0) + + def FORCE_QUOTE(self): + return self.getToken(PLpgSQLParser.FORCE_QUOTE, 0) + + def FORMAT(self): + return self.getToken(PLpgSQLParser.FORMAT, 0) + + def GETTOKEN(self): + return self.getToken(PLpgSQLParser.GETTOKEN, 0) + + def HASH(self): + return self.getToken(PLpgSQLParser.HASH, 0) + + def HASHES(self): + return self.getToken(PLpgSQLParser.HASHES, 0) + + def HEADLINE(self): + return self.getToken(PLpgSQLParser.HEADLINE, 0) + + def HYPOTHETICAL(self): + return self.getToken(PLpgSQLParser.HYPOTHETICAL, 0) + + def INDEX_CLEANUP(self): + return self.getToken(PLpgSQLParser.INDEX_CLEANUP, 0) + + def INIT(self): + return self.getToken(PLpgSQLParser.INIT, 0) + + def INITCOND(self): + return self.getToken(PLpgSQLParser.INITCOND, 0) + + def INTERNALLENGTH(self): + return self.getToken(PLpgSQLParser.INTERNALLENGTH, 0) + + def JSON(self): + return self.getToken(PLpgSQLParser.JSON, 0) + + def LC_COLLATE(self): + return self.getToken(PLpgSQLParser.LC_COLLATE, 0) + + def LC_CTYPE(self): + return self.getToken(PLpgSQLParser.LC_CTYPE, 0) + + def LEFTARG(self): + return self.getToken(PLpgSQLParser.LEFTARG, 0) + + def LEXIZE(self): + return self.getToken(PLpgSQLParser.LEXIZE, 0) + + def LEXTYPES(self): + return self.getToken(PLpgSQLParser.LEXTYPES, 0) + + def LIST(self): + return self.getToken(PLpgSQLParser.LIST, 0) + + def LOCALE(self): + return self.getToken(PLpgSQLParser.LOCALE, 0) + + def LOGIN(self): + return self.getToken(PLpgSQLParser.LOGIN, 0) + + def MAIN(self): + return self.getToken(PLpgSQLParser.MAIN, 0) + + def MERGES(self): + return self.getToken(PLpgSQLParser.MERGES, 0) + + def MFINALFUNC(self): + return self.getToken(PLpgSQLParser.MFINALFUNC, 0) + + def MFINALFUNC_EXTRA(self): + return self.getToken(PLpgSQLParser.MFINALFUNC_EXTRA, 0) + + def MFINALFUNC_MODIFY(self): + return self.getToken(PLpgSQLParser.MFINALFUNC_MODIFY, 0) + + def MINITCOND(self): + return self.getToken(PLpgSQLParser.MINITCOND, 0) + + def MINVFUNC(self): + return self.getToken(PLpgSQLParser.MINVFUNC, 0) + + def MODULUS(self): + return self.getToken(PLpgSQLParser.MODULUS, 0) + + def MSFUNC(self): + return self.getToken(PLpgSQLParser.MSFUNC, 0) + + def MSSPACE(self): + return self.getToken(PLpgSQLParser.MSSPACE, 0) + + def MSTYPE(self): + return self.getToken(PLpgSQLParser.MSTYPE, 0) + + def NEGATOR(self): + return self.getToken(PLpgSQLParser.NEGATOR, 0) + + def NOBYPASSRLS(self): + return self.getToken(PLpgSQLParser.NOBYPASSRLS, 0) + + def NOCREATEDB(self): + return self.getToken(PLpgSQLParser.NOCREATEDB, 0) + + def NOCREATEROLE(self): + return self.getToken(PLpgSQLParser.NOCREATEROLE, 0) + + def NOINHERIT(self): + return self.getToken(PLpgSQLParser.NOINHERIT, 0) + + def NOLOGIN(self): + return self.getToken(PLpgSQLParser.NOLOGIN, 0) + + def NOREPLICATION(self): + return self.getToken(PLpgSQLParser.NOREPLICATION, 0) + + def NOSUPERUSER(self): + return self.getToken(PLpgSQLParser.NOSUPERUSER, 0) + + def OUTPUT(self): + return self.getToken(PLpgSQLParser.OUTPUT, 0) + + def PASSEDBYVALUE(self): + return self.getToken(PLpgSQLParser.PASSEDBYVALUE, 0) + + def PATH(self): + return self.getToken(PLpgSQLParser.PATH, 0) + + def PERMISSIVE(self): + return self.getToken(PLpgSQLParser.PERMISSIVE, 0) + + def PLAIN(self): + return self.getToken(PLpgSQLParser.PLAIN, 0) + + def PREFERRED(self): + return self.getToken(PLpgSQLParser.PREFERRED, 0) + + def PROVIDER(self): + return self.getToken(PLpgSQLParser.PROVIDER, 0) + + def READ_ONLY(self): + return self.getToken(PLpgSQLParser.READ_ONLY, 0) + + def READ_WRITE(self): + return self.getToken(PLpgSQLParser.READ_WRITE, 0) + + def RECEIVE(self): + return self.getToken(PLpgSQLParser.RECEIVE, 0) + + def REPLICATION(self): + return self.getToken(PLpgSQLParser.REPLICATION, 0) + + def REMAINDER(self): + return self.getToken(PLpgSQLParser.REMAINDER, 0) + + def RESTRICTED(self): + return self.getToken(PLpgSQLParser.RESTRICTED, 0) + + def RESTRICTIVE(self): + return self.getToken(PLpgSQLParser.RESTRICTIVE, 0) + + def RIGHTARG(self): + return self.getToken(PLpgSQLParser.RIGHTARG, 0) + + def SAFE(self): + return self.getToken(PLpgSQLParser.SAFE, 0) + + def SEND(self): + return self.getToken(PLpgSQLParser.SEND, 0) + + def SERIALFUNC(self): + return self.getToken(PLpgSQLParser.SERIALFUNC, 0) + + def SETTINGS(self): + return self.getToken(PLpgSQLParser.SETTINGS, 0) + + def SFUNC(self): + return self.getToken(PLpgSQLParser.SFUNC, 0) + + def SHAREABLE(self): + return self.getToken(PLpgSQLParser.SHAREABLE, 0) + + def SKIP_LOCKED(self): + return self.getToken(PLpgSQLParser.SKIP_LOCKED, 0) + + def SORTOP(self): + return self.getToken(PLpgSQLParser.SORTOP, 0) + + def SSPACE(self): + return self.getToken(PLpgSQLParser.SSPACE, 0) + + def STYPE(self): + return self.getToken(PLpgSQLParser.STYPE, 0) + + def SUBTYPE(self): + return self.getToken(PLpgSQLParser.SUBTYPE, 0) + + def SUBTYPE_DIFF(self): + return self.getToken(PLpgSQLParser.SUBTYPE_DIFF, 0) + + def SUBTYPE_OPCLASS(self): + return self.getToken(PLpgSQLParser.SUBTYPE_OPCLASS, 0) + + def SUMMARY(self): + return self.getToken(PLpgSQLParser.SUMMARY, 0) + + def SUPERUSER(self): + return self.getToken(PLpgSQLParser.SUPERUSER, 0) + + def TIMING(self): + return self.getToken(PLpgSQLParser.TIMING, 0) + + def TYPMOD_IN(self): + return self.getToken(PLpgSQLParser.TYPMOD_IN, 0) + + def TYPMOD_OUT(self): + return self.getToken(PLpgSQLParser.TYPMOD_OUT, 0) + + def UNSAFE(self): + return self.getToken(PLpgSQLParser.UNSAFE, 0) + + def USAGE(self): + return self.getToken(PLpgSQLParser.USAGE, 0) + + def VARIABLE(self): + return self.getToken(PLpgSQLParser.VARIABLE, 0) + + def YAML(self): + return self.getToken(PLpgSQLParser.YAML, 0) + + def ALIAS(self): + return self.getToken(PLpgSQLParser.ALIAS, 0) + + def ASSERT(self): + return self.getToken(PLpgSQLParser.ASSERT, 0) + + def CONSTANT(self): + return self.getToken(PLpgSQLParser.CONSTANT, 0) + + def DATATYPE(self): + return self.getToken(PLpgSQLParser.DATATYPE, 0) + + def DEBUG(self): + return self.getToken(PLpgSQLParser.DEBUG, 0) + + def DETAIL(self): + return self.getToken(PLpgSQLParser.DETAIL, 0) + + def DIAGNOSTICS(self): + return self.getToken(PLpgSQLParser.DIAGNOSTICS, 0) + + def ELSEIF(self): + return self.getToken(PLpgSQLParser.ELSEIF, 0) + + def ELSIF(self): + return self.getToken(PLpgSQLParser.ELSIF, 0) + + def ERRCODE(self): + return self.getToken(PLpgSQLParser.ERRCODE, 0) + + def EXIT(self): + return self.getToken(PLpgSQLParser.EXIT, 0) + + def EXCEPTION(self): + return self.getToken(PLpgSQLParser.EXCEPTION, 0) + + def FOREACH(self): + return self.getToken(PLpgSQLParser.FOREACH, 0) + + def GET(self): + return self.getToken(PLpgSQLParser.GET, 0) + + def HINT(self): + return self.getToken(PLpgSQLParser.HINT, 0) + + def INFO(self): + return self.getToken(PLpgSQLParser.INFO, 0) + + def LOG(self): + return self.getToken(PLpgSQLParser.LOG, 0) + + def LOOP(self): + return self.getToken(PLpgSQLParser.LOOP, 0) + + def MESSAGE(self): + return self.getToken(PLpgSQLParser.MESSAGE, 0) + + def NOTICE(self): + return self.getToken(PLpgSQLParser.NOTICE, 0) + + def OPEN(self): + return self.getToken(PLpgSQLParser.OPEN, 0) + + def PERFORM(self): + return self.getToken(PLpgSQLParser.PERFORM, 0) + + def QUERY(self): + return self.getToken(PLpgSQLParser.QUERY, 0) + + def RAISE(self): + return self.getToken(PLpgSQLParser.RAISE, 0) + + def RECORD(self): + return self.getToken(PLpgSQLParser.RECORD, 0) + + def RETURN(self): + return self.getToken(PLpgSQLParser.RETURN, 0) + + def REVERSE(self): + return self.getToken(PLpgSQLParser.REVERSE, 0) + + def ROWTYPE(self): + return self.getToken(PLpgSQLParser.ROWTYPE, 0) + + def SLICE(self): + return self.getToken(PLpgSQLParser.SLICE, 0) + + def SQLSTATE(self): + return self.getToken(PLpgSQLParser.SQLSTATE, 0) + + def STACKED(self): + return self.getToken(PLpgSQLParser.STACKED, 0) + + def WARNING(self): + return self.getToken(PLpgSQLParser.WARNING, 0) + + def WHILE(self): + return self.getToken(PLpgSQLParser.WHILE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_tokens_nonkeyword + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTokens_nonkeyword" ): + listener.enterTokens_nonkeyword(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTokens_nonkeyword" ): + listener.exitTokens_nonkeyword(self) + + + + + def tokens_nonkeyword(self): + + localctx = PLpgSQLParser.Tokens_nonkeywordContext(self, self._ctx, self.state) + self.enterRule(localctx, 540, self.RULE_tokens_nonkeyword) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5348 + _la = self._input.LA(1) + if not(((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_qualified_name_nontypeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.schema = None # IdentifierContext + + def identifier_nontype(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_nontypeContext,0) + + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_qualified_name_nontype + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_qualified_name_nontype" ): + listener.enterSchema_qualified_name_nontype(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_qualified_name_nontype" ): + listener.exitSchema_qualified_name_nontype(self) + + + + + def schema_qualified_name_nontype(self): + + localctx = PLpgSQLParser.Schema_qualified_name_nontypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 542, self.RULE_schema_qualified_name_nontype) + try: + self.state = 5355 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,661,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5350 + self.identifier_nontype() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5351 + localctx.schema = self.identifier() + self.state = 5352 + self.match(PLpgSQLParser.DOT) + self.state = 5353 + self.identifier_nontype() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Type_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_type_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterType_list" ): + listener.enterType_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitType_list" ): + listener.exitType_list(self) + + + + + def type_list(self): + + localctx = PLpgSQLParser.Type_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 544, self.RULE_type_list) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5357 + self.data_type() + self.state = 5362 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5358 + self.match(PLpgSQLParser.COMMA) + self.state = 5359 + self.data_type() + self.state = 5364 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Data_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def predefined_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Predefined_typeContext,0) + + + def SETOF(self): + return self.getToken(PLpgSQLParser.SETOF, 0) + + def ARRAY(self): + return self.getToken(PLpgSQLParser.ARRAY, 0) + + def array_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Array_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Array_typeContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_data_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterData_type" ): + listener.enterData_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitData_type" ): + listener.exitData_type(self) + + + + + def data_type(self): + + localctx = PLpgSQLParser.Data_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 546, self.RULE_data_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5366 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,663,self._ctx) + if la_ == 1: + self.state = 5365 + self.match(PLpgSQLParser.SETOF) + + + self.state = 5368 + self.predefined_type() + self.state = 5378 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,666,self._ctx) + if la_ == 1: + self.state = 5369 + self.match(PLpgSQLParser.ARRAY) + self.state = 5371 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,664,self._ctx) + if la_ == 1: + self.state = 5370 + self.array_type() + + + + elif la_ == 2: + self.state = 5374 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 5373 + self.array_type() + + else: + raise NoViableAltException(self) + self.state = 5376 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,665,self._ctx) + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Array_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_BRACKET(self): + return self.getToken(PLpgSQLParser.LEFT_BRACKET, 0) + + def RIGHT_BRACKET(self): + return self.getToken(PLpgSQLParser.RIGHT_BRACKET, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_array_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArray_type" ): + listener.enterArray_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArray_type" ): + listener.exitArray_type(self) + + + + + def array_type(self): + + localctx = PLpgSQLParser.Array_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 548, self.RULE_array_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5380 + self.match(PLpgSQLParser.LEFT_BRACKET) + self.state = 5382 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NUMBER_LITERAL: + self.state = 5381 + self.match(PLpgSQLParser.NUMBER_LITERAL) + + + self.state = 5384 + self.match(PLpgSQLParser.RIGHT_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Predefined_typeContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BIGINT(self): + return self.getToken(PLpgSQLParser.BIGINT, 0) + + def BIT(self): + return self.getToken(PLpgSQLParser.BIT, 0) + + def VARYING(self): + return self.getToken(PLpgSQLParser.VARYING, 0) + + def type_length(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_lengthContext,0) + + + def BOOLEAN(self): + return self.getToken(PLpgSQLParser.BOOLEAN, 0) + + def DEC(self): + return self.getToken(PLpgSQLParser.DEC, 0) + + def precision_param(self): + return self.getTypedRuleContext(PLpgSQLParser.Precision_paramContext,0) + + + def DECIMAL(self): + return self.getToken(PLpgSQLParser.DECIMAL, 0) + + def DOUBLE(self): + return self.getToken(PLpgSQLParser.DOUBLE, 0) + + def PRECISION(self): + return self.getToken(PLpgSQLParser.PRECISION, 0) + + def FLOAT(self): + return self.getToken(PLpgSQLParser.FLOAT, 0) + + def INT(self): + return self.getToken(PLpgSQLParser.INT, 0) + + def INTEGER(self): + return self.getToken(PLpgSQLParser.INTEGER, 0) + + def INTERVAL(self): + return self.getToken(PLpgSQLParser.INTERVAL, 0) + + def interval_field(self): + return self.getTypedRuleContext(PLpgSQLParser.Interval_fieldContext,0) + + + def CHARACTER(self): + return self.getToken(PLpgSQLParser.CHARACTER, 0) + + def CHAR(self): + return self.getToken(PLpgSQLParser.CHAR, 0) + + def NATIONAL(self): + return self.getToken(PLpgSQLParser.NATIONAL, 0) + + def NCHAR(self): + return self.getToken(PLpgSQLParser.NCHAR, 0) + + def NUMERIC(self): + return self.getToken(PLpgSQLParser.NUMERIC, 0) + + def REAL(self): + return self.getToken(PLpgSQLParser.REAL, 0) + + def SMALLINT(self): + return self.getToken(PLpgSQLParser.SMALLINT, 0) + + def TIME(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.TIME) + else: + return self.getToken(PLpgSQLParser.TIME, i) + + def ZONE(self): + return self.getToken(PLpgSQLParser.ZONE, 0) + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def WITHOUT(self): + return self.getToken(PLpgSQLParser.WITHOUT, 0) + + def TIMESTAMP(self): + return self.getToken(PLpgSQLParser.TIMESTAMP, 0) + + def VARCHAR(self): + return self.getToken(PLpgSQLParser.VARCHAR, 0) + + def schema_qualified_name_nontype(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_name_nontypeContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_predefined_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPredefined_type" ): + listener.enterPredefined_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPredefined_type" ): + listener.exitPredefined_type(self) + + + + + def predefined_type(self): + + localctx = PLpgSQLParser.Predefined_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 550, self.RULE_predefined_type) + self._la = 0 # Token type + try: + self.state = 5477 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,688,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5386 + self.match(PLpgSQLParser.BIGINT) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5387 + self.match(PLpgSQLParser.BIT) + self.state = 5389 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,668,self._ctx) + if la_ == 1: + self.state = 5388 + self.match(PLpgSQLParser.VARYING) + + + self.state = 5392 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,669,self._ctx) + if la_ == 1: + self.state = 5391 + self.type_length() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5394 + self.match(PLpgSQLParser.BOOLEAN) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5395 + self.match(PLpgSQLParser.DEC) + self.state = 5397 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,670,self._ctx) + if la_ == 1: + self.state = 5396 + self.precision_param() + + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 5399 + self.match(PLpgSQLParser.DECIMAL) + self.state = 5401 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,671,self._ctx) + if la_ == 1: + self.state = 5400 + self.precision_param() + + + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 5403 + self.match(PLpgSQLParser.DOUBLE) + self.state = 5404 + self.match(PLpgSQLParser.PRECISION) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 5405 + self.match(PLpgSQLParser.FLOAT) + self.state = 5407 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,672,self._ctx) + if la_ == 1: + self.state = 5406 + self.precision_param() + + + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 5409 + self.match(PLpgSQLParser.INT) + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 5410 + self.match(PLpgSQLParser.INTEGER) + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 5411 + self.match(PLpgSQLParser.INTERVAL) + self.state = 5413 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,673,self._ctx) + if la_ == 1: + self.state = 5412 + self.interval_field() + + + self.state = 5416 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,674,self._ctx) + if la_ == 1: + self.state = 5415 + self.type_length() + + + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 5419 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NATIONAL: + self.state = 5418 + self.match(PLpgSQLParser.NATIONAL) + + + self.state = 5421 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CHAR or _la==PLpgSQLParser.CHARACTER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5423 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,676,self._ctx) + if la_ == 1: + self.state = 5422 + self.match(PLpgSQLParser.VARYING) + + + self.state = 5426 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,677,self._ctx) + if la_ == 1: + self.state = 5425 + self.type_length() + + + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 5428 + self.match(PLpgSQLParser.NCHAR) + self.state = 5430 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,678,self._ctx) + if la_ == 1: + self.state = 5429 + self.match(PLpgSQLParser.VARYING) + + + self.state = 5433 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,679,self._ctx) + if la_ == 1: + self.state = 5432 + self.type_length() + + + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 5435 + self.match(PLpgSQLParser.NUMERIC) + self.state = 5437 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,680,self._ctx) + if la_ == 1: + self.state = 5436 + self.precision_param() + + + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 5439 + self.match(PLpgSQLParser.REAL) + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 5440 + self.match(PLpgSQLParser.SMALLINT) + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 5441 + self.match(PLpgSQLParser.TIME) + self.state = 5443 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,681,self._ctx) + if la_ == 1: + self.state = 5442 + self.type_length() + + + self.state = 5448 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,682,self._ctx) + if la_ == 1: + self.state = 5445 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.WITHOUT or _la==PLpgSQLParser.WITH): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5446 + self.match(PLpgSQLParser.TIME) + self.state = 5447 + self.match(PLpgSQLParser.ZONE) + + + pass + + elif la_ == 17: + self.enterOuterAlt(localctx, 17) + self.state = 5450 + self.match(PLpgSQLParser.TIMESTAMP) + self.state = 5452 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,683,self._ctx) + if la_ == 1: + self.state = 5451 + self.type_length() + + + self.state = 5457 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,684,self._ctx) + if la_ == 1: + self.state = 5454 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.WITHOUT or _la==PLpgSQLParser.WITH): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5455 + self.match(PLpgSQLParser.TIME) + self.state = 5456 + self.match(PLpgSQLParser.ZONE) + + + pass + + elif la_ == 18: + self.enterOuterAlt(localctx, 18) + self.state = 5459 + self.match(PLpgSQLParser.VARCHAR) + self.state = 5461 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,685,self._ctx) + if la_ == 1: + self.state = 5460 + self.type_length() + + + pass + + elif la_ == 19: + self.enterOuterAlt(localctx, 19) + self.state = 5463 + self.schema_qualified_name_nontype() + self.state = 5475 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,687,self._ctx) + if la_ == 1: + self.state = 5464 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5465 + self.vex(0) + self.state = 5470 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5466 + self.match(PLpgSQLParser.COMMA) + self.state = 5467 + self.vex(0) + self.state = 5472 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5473 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Interval_fieldContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def YEAR(self): + return self.getToken(PLpgSQLParser.YEAR, 0) + + def MONTH(self): + return self.getToken(PLpgSQLParser.MONTH, 0) + + def DAY(self): + return self.getToken(PLpgSQLParser.DAY, 0) + + def HOUR(self): + return self.getToken(PLpgSQLParser.HOUR, 0) + + def MINUTE(self): + return self.getToken(PLpgSQLParser.MINUTE, 0) + + def SECOND(self): + return self.getToken(PLpgSQLParser.SECOND, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_interval_field + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterval_field" ): + listener.enterInterval_field(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterval_field" ): + listener.exitInterval_field(self) + + + + + def interval_field(self): + + localctx = PLpgSQLParser.Interval_fieldContext(self, self._ctx, self.state) + self.enterRule(localctx, 552, self.RULE_interval_field) + try: + self.state = 5506 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,689,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5479 + self.match(PLpgSQLParser.YEAR) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5480 + self.match(PLpgSQLParser.MONTH) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5481 + self.match(PLpgSQLParser.DAY) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5482 + self.match(PLpgSQLParser.HOUR) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 5483 + self.match(PLpgSQLParser.MINUTE) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 5484 + self.match(PLpgSQLParser.SECOND) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 5485 + self.match(PLpgSQLParser.YEAR) + self.state = 5486 + self.match(PLpgSQLParser.TO) + self.state = 5487 + self.match(PLpgSQLParser.MONTH) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 5488 + self.match(PLpgSQLParser.DAY) + self.state = 5489 + self.match(PLpgSQLParser.TO) + self.state = 5490 + self.match(PLpgSQLParser.HOUR) + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 5491 + self.match(PLpgSQLParser.DAY) + self.state = 5492 + self.match(PLpgSQLParser.TO) + self.state = 5493 + self.match(PLpgSQLParser.MINUTE) + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 5494 + self.match(PLpgSQLParser.DAY) + self.state = 5495 + self.match(PLpgSQLParser.TO) + self.state = 5496 + self.match(PLpgSQLParser.SECOND) + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 5497 + self.match(PLpgSQLParser.HOUR) + self.state = 5498 + self.match(PLpgSQLParser.TO) + self.state = 5499 + self.match(PLpgSQLParser.MINUTE) + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 5500 + self.match(PLpgSQLParser.HOUR) + self.state = 5501 + self.match(PLpgSQLParser.TO) + self.state = 5502 + self.match(PLpgSQLParser.SECOND) + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 5503 + self.match(PLpgSQLParser.MINUTE) + self.state = 5504 + self.match(PLpgSQLParser.TO) + self.state = 5505 + self.match(PLpgSQLParser.SECOND) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Type_lengthContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_type_length + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterType_length" ): + listener.enterType_length(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitType_length" ): + listener.exitType_length(self) + + + + + def type_length(self): + + localctx = PLpgSQLParser.Type_lengthContext(self, self._ctx, self.state) + self.enterRule(localctx, 554, self.RULE_type_length) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5508 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5509 + self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 5510 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Precision_paramContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.precision = None # Token + self.scale = None # Token + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def NUMBER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NUMBER_LITERAL) + else: + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, i) + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_precision_param + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrecision_param" ): + listener.enterPrecision_param(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrecision_param" ): + listener.exitPrecision_param(self) + + + + + def precision_param(self): + + localctx = PLpgSQLParser.Precision_paramContext(self, self._ctx, self.state) + self.enterRule(localctx, 556, self.RULE_precision_param) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5512 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5513 + localctx.precision = self.match(PLpgSQLParser.NUMBER_LITERAL) + self.state = 5516 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 5514 + self.match(PLpgSQLParser.COMMA) + self.state = 5515 + localctx.scale = self.match(PLpgSQLParser.NUMBER_LITERAL) + + + self.state = 5518 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VexContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def indirection_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Indirection_listContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def PLUS(self): + return self.getToken(PLpgSQLParser.PLUS, 0) + + def MINUS(self): + return self.getToken(PLpgSQLParser.MINUS, 0) + + def op(self): + return self.getTypedRuleContext(PLpgSQLParser.OpContext,0) + + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def value_expression_primary(self): + return self.getTypedRuleContext(PLpgSQLParser.Value_expression_primaryContext,0) + + + def AT(self): + return self.getToken(PLpgSQLParser.AT, 0) + + def TIME(self): + return self.getToken(PLpgSQLParser.TIME, 0) + + def ZONE(self): + return self.getToken(PLpgSQLParser.ZONE, 0) + + def EXP(self): + return self.getToken(PLpgSQLParser.EXP, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def DIVIDE(self): + return self.getToken(PLpgSQLParser.DIVIDE, 0) + + def MODULAR(self): + return self.getToken(PLpgSQLParser.MODULAR, 0) + + def BETWEEN(self): + return self.getToken(PLpgSQLParser.BETWEEN, 0) + + def vex_b(self): + return self.getTypedRuleContext(PLpgSQLParser.Vex_bContext,0) + + + def AND(self): + return self.getToken(PLpgSQLParser.AND, 0) + + def ASYMMETRIC(self): + return self.getToken(PLpgSQLParser.ASYMMETRIC, 0) + + def SYMMETRIC(self): + return self.getToken(PLpgSQLParser.SYMMETRIC, 0) + + def LIKE(self): + return self.getToken(PLpgSQLParser.LIKE, 0) + + def ILIKE(self): + return self.getToken(PLpgSQLParser.ILIKE, 0) + + def SIMILAR(self): + return self.getToken(PLpgSQLParser.SIMILAR, 0) + + def TO(self): + return self.getToken(PLpgSQLParser.TO, 0) + + def ESCAPE(self): + return self.getToken(PLpgSQLParser.ESCAPE, 0) + + def LTH(self): + return self.getToken(PLpgSQLParser.LTH, 0) + + def GTH(self): + return self.getToken(PLpgSQLParser.GTH, 0) + + def LEQ(self): + return self.getToken(PLpgSQLParser.LEQ, 0) + + def GEQ(self): + return self.getToken(PLpgSQLParser.GEQ, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def NOT_EQUAL(self): + return self.getToken(PLpgSQLParser.NOT_EQUAL, 0) + + def IS(self): + return self.getToken(PLpgSQLParser.IS, 0) + + def DISTINCT(self): + return self.getToken(PLpgSQLParser.DISTINCT, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def OR(self): + return self.getToken(PLpgSQLParser.OR, 0) + + def CAST_EXPRESSION(self): + return self.getToken(PLpgSQLParser.CAST_EXPRESSION, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def collate_identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Collate_identifierContext,0) + + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def select_stmt_no_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmt_no_parensContext,0) + + + def truth_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Truth_valueContext,0) + + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def DOCUMENT(self): + return self.getToken(PLpgSQLParser.DOCUMENT, 0) + + def UNKNOWN(self): + return self.getToken(PLpgSQLParser.UNKNOWN, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def type_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_listContext,0) + + + def ISNULL(self): + return self.getToken(PLpgSQLParser.ISNULL, 0) + + def NOTNULL(self): + return self.getToken(PLpgSQLParser.NOTNULL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_vex + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVex" ): + listener.enterVex(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVex" ): + listener.exitVex(self) + + + + def vex(self, _p:int=0): + _parentctx = self._ctx + _parentState = self.state + localctx = PLpgSQLParser.VexContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 558 + self.enterRecursionRule(localctx, 558, self.RULE_vex, _p) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5545 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,693,self._ctx) + if la_ == 1: + self.state = 5521 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5522 + self.vex(0) + self.state = 5523 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5525 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,691,self._ctx) + if la_ == 1: + self.state = 5524 + self.indirection_list() + + + pass + + elif la_ == 2: + self.state = 5527 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5528 + self.vex(0) + self.state = 5531 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5529 + self.match(PLpgSQLParser.COMMA) + self.state = 5530 + self.vex(0) + self.state = 5533 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.COMMA): + break + + self.state = 5535 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 3: + self.state = 5537 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5538 + self.vex(24) + pass + + elif la_ == 4: + self.state = 5539 + self.op() + self.state = 5540 + self.vex(18) + pass + + elif la_ == 5: + self.state = 5542 + self.match(PLpgSQLParser.NOT) + self.state = 5543 + self.vex(4) + pass + + elif la_ == 6: + self.state = 5544 + self.value_expression_primary() + pass + + + self._ctx.stop = self._input.LT(-1) + self.state = 5682 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,710,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + self.state = 5680 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,709,self._ctx) + if la_ == 1: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5547 + if not self.precpred(self._ctx, 23): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 23)") + self.state = 5548 + self.match(PLpgSQLParser.AT) + self.state = 5549 + self.match(PLpgSQLParser.TIME) + self.state = 5550 + self.match(PLpgSQLParser.ZONE) + self.state = 5551 + self.vex(24) + pass + + elif la_ == 2: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5552 + if not self.precpred(self._ctx, 22): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 22)") + self.state = 5553 + self.match(PLpgSQLParser.EXP) + self.state = 5554 + self.vex(23) + pass + + elif la_ == 3: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5555 + if not self.precpred(self._ctx, 21): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 21)") + self.state = 5556 + _la = self._input.LA(1) + if not(((((_la - 589)) & ~0x3f) == 0 and ((1 << (_la - 589)) & ((1 << (PLpgSQLParser.MULTIPLY - 589)) | (1 << (PLpgSQLParser.DIVIDE - 589)) | (1 << (PLpgSQLParser.MODULAR - 589)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5557 + self.vex(22) + pass + + elif la_ == 4: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5558 + if not self.precpred(self._ctx, 20): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 20)") + self.state = 5559 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5560 + self.vex(21) + pass + + elif la_ == 5: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5561 + if not self.precpred(self._ctx, 19): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 19)") + self.state = 5562 + self.op() + self.state = 5563 + self.vex(20) + pass + + elif la_ == 6: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5565 + if not self.precpred(self._ctx, 15): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 15)") + self.state = 5567 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5566 + self.match(PLpgSQLParser.NOT) + + + self.state = 5569 + self.match(PLpgSQLParser.BETWEEN) + self.state = 5571 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ASYMMETRIC or _la==PLpgSQLParser.SYMMETRIC: + self.state = 5570 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ASYMMETRIC or _la==PLpgSQLParser.SYMMETRIC): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 5573 + self.vex_b(0) + self.state = 5574 + self.match(PLpgSQLParser.AND) + self.state = 5575 + self.vex(16) + pass + + elif la_ == 7: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5577 + if not self.precpred(self._ctx, 14): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 14)") + self.state = 5579 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5578 + self.match(PLpgSQLParser.NOT) + + + self.state = 5585 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LIKE]: + self.state = 5581 + self.match(PLpgSQLParser.LIKE) + pass + elif token in [PLpgSQLParser.ILIKE]: + self.state = 5582 + self.match(PLpgSQLParser.ILIKE) + pass + elif token in [PLpgSQLParser.SIMILAR]: + self.state = 5583 + self.match(PLpgSQLParser.SIMILAR) + self.state = 5584 + self.match(PLpgSQLParser.TO) + pass + else: + raise NoViableAltException(self) + + self.state = 5587 + self.vex(15) + pass + + elif la_ == 8: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5588 + if not self.precpred(self._ctx, 13): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 13)") + self.state = 5590 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5589 + self.match(PLpgSQLParser.NOT) + + + self.state = 5596 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LIKE]: + self.state = 5592 + self.match(PLpgSQLParser.LIKE) + pass + elif token in [PLpgSQLParser.ILIKE]: + self.state = 5593 + self.match(PLpgSQLParser.ILIKE) + pass + elif token in [PLpgSQLParser.SIMILAR]: + self.state = 5594 + self.match(PLpgSQLParser.SIMILAR) + self.state = 5595 + self.match(PLpgSQLParser.TO) + pass + else: + raise NoViableAltException(self) + + self.state = 5598 + self.vex(0) + self.state = 5599 + self.match(PLpgSQLParser.ESCAPE) + self.state = 5600 + self.vex(14) + pass + + elif la_ == 9: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5602 + if not self.precpred(self._ctx, 12): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 12)") + self.state = 5603 + _la = self._input.LA(1) + if not(((((_la - 576)) & ~0x3f) == 0 and ((1 << (_la - 576)) & ((1 << (PLpgSQLParser.EQUAL - 576)) | (1 << (PLpgSQLParser.NOT_EQUAL - 576)) | (1 << (PLpgSQLParser.LTH - 576)) | (1 << (PLpgSQLParser.LEQ - 576)) | (1 << (PLpgSQLParser.GTH - 576)) | (1 << (PLpgSQLParser.GEQ - 576)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5604 + self.vex(13) + pass + + elif la_ == 10: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5605 + if not self.precpred(self._ctx, 10): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") + self.state = 5606 + self.match(PLpgSQLParser.IS) + self.state = 5608 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5607 + self.match(PLpgSQLParser.NOT) + + + self.state = 5610 + self.match(PLpgSQLParser.DISTINCT) + self.state = 5611 + self.match(PLpgSQLParser.FROM) + self.state = 5612 + self.vex(11) + pass + + elif la_ == 11: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5613 + if not self.precpred(self._ctx, 3): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + self.state = 5614 + self.match(PLpgSQLParser.AND) + self.state = 5615 + self.vex(4) + pass + + elif la_ == 12: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5616 + if not self.precpred(self._ctx, 2): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + self.state = 5617 + self.match(PLpgSQLParser.OR) + self.state = 5618 + self.vex(3) + pass + + elif la_ == 13: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5619 + if not self.precpred(self._ctx, 28): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 28)") + self.state = 5620 + self.match(PLpgSQLParser.CAST_EXPRESSION) + self.state = 5621 + self.data_type() + pass + + elif la_ == 14: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5622 + if not self.precpred(self._ctx, 25): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 25)") + self.state = 5623 + self.collate_identifier() + pass + + elif la_ == 15: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5624 + if not self.precpred(self._ctx, 17): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 17)") + self.state = 5625 + self.op() + pass + + elif la_ == 16: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5626 + if not self.precpred(self._ctx, 16): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 16)") + self.state = 5628 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5627 + self.match(PLpgSQLParser.NOT) + + + self.state = 5630 + self.match(PLpgSQLParser.IN) + self.state = 5631 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5641 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,703,self._ctx) + if la_ == 1: + self.state = 5632 + self.select_stmt_no_parens() + pass + + elif la_ == 2: + self.state = 5633 + self.vex(0) + self.state = 5638 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5634 + self.match(PLpgSQLParser.COMMA) + self.state = 5635 + self.vex(0) + self.state = 5640 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + + self.state = 5643 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 17: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5645 + if not self.precpred(self._ctx, 11): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 11)") + self.state = 5646 + self.match(PLpgSQLParser.IS) + self.state = 5648 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5647 + self.match(PLpgSQLParser.NOT) + + + self.state = 5652 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.FALSE, PLpgSQLParser.ON, PLpgSQLParser.TRUE]: + self.state = 5650 + self.truth_value() + pass + elif token in [PLpgSQLParser.NULL]: + self.state = 5651 + self.match(PLpgSQLParser.NULL) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 18: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5654 + if not self.precpred(self._ctx, 9): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") + self.state = 5655 + self.match(PLpgSQLParser.IS) + self.state = 5657 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5656 + self.match(PLpgSQLParser.NOT) + + + self.state = 5659 + self.match(PLpgSQLParser.DOCUMENT) + pass + + elif la_ == 19: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5660 + if not self.precpred(self._ctx, 8): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 8)") + self.state = 5661 + self.match(PLpgSQLParser.IS) + self.state = 5663 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5662 + self.match(PLpgSQLParser.NOT) + + + self.state = 5665 + self.match(PLpgSQLParser.UNKNOWN) + pass + + elif la_ == 20: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5666 + if not self.precpred(self._ctx, 7): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") + self.state = 5667 + self.match(PLpgSQLParser.IS) + self.state = 5669 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5668 + self.match(PLpgSQLParser.NOT) + + + self.state = 5671 + self.match(PLpgSQLParser.OF) + self.state = 5672 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5673 + self.type_list() + self.state = 5674 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 21: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5676 + if not self.precpred(self._ctx, 6): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") + self.state = 5677 + self.match(PLpgSQLParser.ISNULL) + pass + + elif la_ == 22: + localctx = PLpgSQLParser.VexContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex) + self.state = 5678 + if not self.precpred(self._ctx, 5): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") + self.state = 5679 + self.match(PLpgSQLParser.NOTNULL) + pass + + + self.state = 5684 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,710,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + + class Vex_bContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def indirection_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Indirection_listContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def vex_b(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Vex_bContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Vex_bContext,i) + + + def PLUS(self): + return self.getToken(PLpgSQLParser.PLUS, 0) + + def MINUS(self): + return self.getToken(PLpgSQLParser.MINUS, 0) + + def op(self): + return self.getTypedRuleContext(PLpgSQLParser.OpContext,0) + + + def value_expression_primary(self): + return self.getTypedRuleContext(PLpgSQLParser.Value_expression_primaryContext,0) + + + def EXP(self): + return self.getToken(PLpgSQLParser.EXP, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def DIVIDE(self): + return self.getToken(PLpgSQLParser.DIVIDE, 0) + + def MODULAR(self): + return self.getToken(PLpgSQLParser.MODULAR, 0) + + def LTH(self): + return self.getToken(PLpgSQLParser.LTH, 0) + + def GTH(self): + return self.getToken(PLpgSQLParser.GTH, 0) + + def LEQ(self): + return self.getToken(PLpgSQLParser.LEQ, 0) + + def GEQ(self): + return self.getToken(PLpgSQLParser.GEQ, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def NOT_EQUAL(self): + return self.getToken(PLpgSQLParser.NOT_EQUAL, 0) + + def IS(self): + return self.getToken(PLpgSQLParser.IS, 0) + + def DISTINCT(self): + return self.getToken(PLpgSQLParser.DISTINCT, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def CAST_EXPRESSION(self): + return self.getToken(PLpgSQLParser.CAST_EXPRESSION, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def DOCUMENT(self): + return self.getToken(PLpgSQLParser.DOCUMENT, 0) + + def UNKNOWN(self): + return self.getToken(PLpgSQLParser.UNKNOWN, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def type_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_listContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_vex_b + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVex_b" ): + listener.enterVex_b(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVex_b" ): + listener.exitVex_b(self) + + + + def vex_b(self, _p:int=0): + _parentctx = self._ctx + _parentState = self.state + localctx = PLpgSQLParser.Vex_bContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 560 + self.enterRecursionRule(localctx, 560, self.RULE_vex_b, _p) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5708 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,713,self._ctx) + if la_ == 1: + self.state = 5686 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5687 + self.vex(0) + self.state = 5688 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5690 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,711,self._ctx) + if la_ == 1: + self.state = 5689 + self.indirection_list() + + + pass + + elif la_ == 2: + self.state = 5692 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5693 + self.vex(0) + self.state = 5696 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5694 + self.match(PLpgSQLParser.COMMA) + self.state = 5695 + self.vex(0) + self.state = 5698 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.COMMA): + break + + self.state = 5700 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 3: + self.state = 5702 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5703 + self.vex_b(13) + pass + + elif la_ == 4: + self.state = 5704 + self.op() + self.state = 5705 + self.vex_b(8) + pass + + elif la_ == 5: + self.state = 5707 + self.value_expression_primary() + pass + + + self._ctx.stop = self._input.LT(-1) + self.state = 5763 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,719,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + self.state = 5761 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,718,self._ctx) + if la_ == 1: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5710 + if not self.precpred(self._ctx, 12): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 12)") + self.state = 5711 + self.match(PLpgSQLParser.EXP) + self.state = 5712 + self.vex_b(13) + pass + + elif la_ == 2: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5713 + if not self.precpred(self._ctx, 11): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 11)") + self.state = 5714 + _la = self._input.LA(1) + if not(((((_la - 589)) & ~0x3f) == 0 and ((1 << (_la - 589)) & ((1 << (PLpgSQLParser.MULTIPLY - 589)) | (1 << (PLpgSQLParser.DIVIDE - 589)) | (1 << (PLpgSQLParser.MODULAR - 589)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5715 + self.vex_b(12) + pass + + elif la_ == 3: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5716 + if not self.precpred(self._ctx, 10): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 10)") + self.state = 5717 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.PLUS or _la==PLpgSQLParser.MINUS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5718 + self.vex_b(11) + pass + + elif la_ == 4: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5719 + if not self.precpred(self._ctx, 9): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 9)") + self.state = 5720 + self.op() + self.state = 5721 + self.vex_b(10) + pass + + elif la_ == 5: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5723 + if not self.precpred(self._ctx, 6): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 6)") + self.state = 5724 + _la = self._input.LA(1) + if not(((((_la - 576)) & ~0x3f) == 0 and ((1 << (_la - 576)) & ((1 << (PLpgSQLParser.EQUAL - 576)) | (1 << (PLpgSQLParser.NOT_EQUAL - 576)) | (1 << (PLpgSQLParser.LTH - 576)) | (1 << (PLpgSQLParser.LEQ - 576)) | (1 << (PLpgSQLParser.GTH - 576)) | (1 << (PLpgSQLParser.GEQ - 576)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5725 + self.vex_b(7) + pass + + elif la_ == 6: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5726 + if not self.precpred(self._ctx, 5): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") + self.state = 5727 + self.match(PLpgSQLParser.IS) + self.state = 5729 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5728 + self.match(PLpgSQLParser.NOT) + + + self.state = 5731 + self.match(PLpgSQLParser.DISTINCT) + self.state = 5732 + self.match(PLpgSQLParser.FROM) + self.state = 5733 + self.vex_b(6) + pass + + elif la_ == 7: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5734 + if not self.precpred(self._ctx, 16): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 16)") + self.state = 5735 + self.match(PLpgSQLParser.CAST_EXPRESSION) + self.state = 5736 + self.data_type() + pass + + elif la_ == 8: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5737 + if not self.precpred(self._ctx, 7): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 7)") + self.state = 5738 + self.op() + pass + + elif la_ == 9: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5739 + if not self.precpred(self._ctx, 4): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") + self.state = 5740 + self.match(PLpgSQLParser.IS) + self.state = 5742 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5741 + self.match(PLpgSQLParser.NOT) + + + self.state = 5744 + self.match(PLpgSQLParser.DOCUMENT) + pass + + elif la_ == 10: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5745 + if not self.precpred(self._ctx, 3): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + self.state = 5746 + self.match(PLpgSQLParser.IS) + self.state = 5748 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5747 + self.match(PLpgSQLParser.NOT) + + + self.state = 5750 + self.match(PLpgSQLParser.UNKNOWN) + pass + + elif la_ == 11: + localctx = PLpgSQLParser.Vex_bContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_vex_b) + self.state = 5751 + if not self.precpred(self._ctx, 2): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + self.state = 5752 + self.match(PLpgSQLParser.IS) + self.state = 5754 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 5753 + self.match(PLpgSQLParser.NOT) + + + self.state = 5756 + self.match(PLpgSQLParser.OF) + self.state = 5757 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5758 + self.type_list() + self.state = 5759 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + + self.state = 5765 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,719,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + + class OpContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def op_chars(self): + return self.getTypedRuleContext(PLpgSQLParser.Op_charsContext,0) + + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def all_simple_op(self): + return self.getTypedRuleContext(PLpgSQLParser.All_simple_opContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOp" ): + listener.enterOp(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOp" ): + listener.exitOp(self) + + + + + def op(self): + + localctx = PLpgSQLParser.OpContext(self, self._ctx, self.state) + self.enterRule(localctx, 562, self.RULE_op) + try: + self.state = 5774 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS]: + self.enterOuterAlt(localctx, 1) + self.state = 5766 + self.op_chars() + pass + elif token in [PLpgSQLParser.OPERATOR]: + self.enterOuterAlt(localctx, 2) + self.state = 5767 + self.match(PLpgSQLParser.OPERATOR) + self.state = 5768 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5769 + self.identifier() + self.state = 5770 + self.match(PLpgSQLParser.DOT) + self.state = 5771 + self.all_simple_op() + self.state = 5772 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class All_op_refContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def all_simple_op(self): + return self.getTypedRuleContext(PLpgSQLParser.All_simple_opContext,0) + + + def OPERATOR(self): + return self.getToken(PLpgSQLParser.OPERATOR, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def DOT(self): + return self.getToken(PLpgSQLParser.DOT, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_all_op_ref + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAll_op_ref" ): + listener.enterAll_op_ref(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAll_op_ref" ): + listener.exitAll_op_ref(self) + + + + + def all_op_ref(self): + + localctx = PLpgSQLParser.All_op_refContext(self, self._ctx, self.state) + self.enterRule(localctx, 564, self.RULE_all_op_ref) + try: + self.state = 5784 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.EQUAL, PLpgSQLParser.NOT_EQUAL, PLpgSQLParser.LTH, PLpgSQLParser.LEQ, PLpgSQLParser.GTH, PLpgSQLParser.GEQ, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.DIVIDE, PLpgSQLParser.MODULAR, PLpgSQLParser.EXP, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS]: + self.enterOuterAlt(localctx, 1) + self.state = 5776 + self.all_simple_op() + pass + elif token in [PLpgSQLParser.OPERATOR]: + self.enterOuterAlt(localctx, 2) + self.state = 5777 + self.match(PLpgSQLParser.OPERATOR) + self.state = 5778 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5779 + self.identifier() + self.state = 5780 + self.match(PLpgSQLParser.DOT) + self.state = 5781 + self.all_simple_op() + self.state = 5782 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Datetime_overlapsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def OVERLAPS(self): + return self.getToken(PLpgSQLParser.OVERLAPS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_datetime_overlaps + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDatetime_overlaps" ): + listener.enterDatetime_overlaps(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDatetime_overlaps" ): + listener.exitDatetime_overlaps(self) + + + + + def datetime_overlaps(self): + + localctx = PLpgSQLParser.Datetime_overlapsContext(self, self._ctx, self.state) + self.enterRule(localctx, 566, self.RULE_datetime_overlaps) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5786 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5787 + self.vex(0) + self.state = 5788 + self.match(PLpgSQLParser.COMMA) + self.state = 5789 + self.vex(0) + self.state = 5790 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5791 + self.match(PLpgSQLParser.OVERLAPS) + self.state = 5792 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5793 + self.vex(0) + self.state = 5794 + self.match(PLpgSQLParser.COMMA) + self.state = 5795 + self.vex(0) + self.state = 5796 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Value_expression_primaryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unsigned_value_specification(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_value_specificationContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def select_stmt_no_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmt_no_parensContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def indirection_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Indirection_listContext,0) + + + def case_expression(self): + return self.getTypedRuleContext(PLpgSQLParser.Case_expressionContext,0) + + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def comparison_mod(self): + return self.getTypedRuleContext(PLpgSQLParser.Comparison_modContext,0) + + + def EXISTS(self): + return self.getToken(PLpgSQLParser.EXISTS, 0) + + def table_subquery(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_subqueryContext,0) + + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def indirection_var(self): + return self.getTypedRuleContext(PLpgSQLParser.Indirection_varContext,0) + + + def array_expression(self): + return self.getTypedRuleContext(PLpgSQLParser.Array_expressionContext,0) + + + def type_coercion(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_coercionContext,0) + + + def datetime_overlaps(self): + return self.getTypedRuleContext(PLpgSQLParser.Datetime_overlapsContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_value_expression_primary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValue_expression_primary" ): + listener.enterValue_expression_primary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValue_expression_primary" ): + listener.exitValue_expression_primary(self) + + + + + def value_expression_primary(self): + + localctx = PLpgSQLParser.Value_expression_primaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 568, self.RULE_value_expression_primary) + try: + self.state = 5816 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,723,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5798 + self.unsigned_value_specification() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5799 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5800 + self.select_stmt_no_parens() + self.state = 5801 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5803 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,722,self._ctx) + if la_ == 1: + self.state = 5802 + self.indirection_list() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5805 + self.case_expression() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5806 + self.match(PLpgSQLParser.NULL) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 5807 + self.match(PLpgSQLParser.MULTIPLY) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 5808 + self.comparison_mod() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 5809 + self.match(PLpgSQLParser.EXISTS) + self.state = 5810 + self.table_subquery() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 5811 + self.function_call() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 5812 + self.indirection_var() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 5813 + self.array_expression() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 5814 + self.type_coercion() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 5815 + self.datetime_overlaps() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Unsigned_value_specificationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unsigned_numeric_literal(self): + return self.getTypedRuleContext(PLpgSQLParser.Unsigned_numeric_literalContext,0) + + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def truth_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Truth_valueContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_unsigned_value_specification + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnsigned_value_specification" ): + listener.enterUnsigned_value_specification(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnsigned_value_specification" ): + listener.exitUnsigned_value_specification(self) + + + + + def unsigned_value_specification(self): + + localctx = PLpgSQLParser.Unsigned_value_specificationContext(self, self._ctx, self.state) + self.enterRule(localctx, 570, self.RULE_unsigned_value_specification) + try: + self.state = 5821 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER]: + self.enterOuterAlt(localctx, 1) + self.state = 5818 + self.unsigned_numeric_literal() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.enterOuterAlt(localctx, 2) + self.state = 5819 + self.character_string() + pass + elif token in [PLpgSQLParser.FALSE, PLpgSQLParser.ON, PLpgSQLParser.TRUE]: + self.enterOuterAlt(localctx, 3) + self.state = 5820 + self.truth_value() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Unsigned_numeric_literalContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def REAL_NUMBER(self): + return self.getToken(PLpgSQLParser.REAL_NUMBER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_unsigned_numeric_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnsigned_numeric_literal" ): + listener.enterUnsigned_numeric_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnsigned_numeric_literal" ): + listener.exitUnsigned_numeric_literal(self) + + + + + def unsigned_numeric_literal(self): + + localctx = PLpgSQLParser.Unsigned_numeric_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 572, self.RULE_unsigned_numeric_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5823 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.NUMBER_LITERAL or _la==PLpgSQLParser.REAL_NUMBER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Truth_valueContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRUE(self): + return self.getToken(PLpgSQLParser.TRUE, 0) + + def FALSE(self): + return self.getToken(PLpgSQLParser.FALSE, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_truth_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTruth_value" ): + listener.enterTruth_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTruth_value" ): + listener.exitTruth_value(self) + + + + + def truth_value(self): + + localctx = PLpgSQLParser.Truth_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 574, self.RULE_truth_value) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5825 + _la = self._input.LA(1) + if not(((((_la - 397)) & ~0x3f) == 0 and ((1 << (_la - 397)) & ((1 << (PLpgSQLParser.FALSE - 397)) | (1 << (PLpgSQLParser.ON - 397)) | (1 << (PLpgSQLParser.TRUE - 397)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Case_expressionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self._vex = None # VexContext + self.r = list() # of VexContexts + + def CASE(self): + return self.getToken(PLpgSQLParser.CASE, 0) + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def WHEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WHEN) + else: + return self.getToken(PLpgSQLParser.WHEN, i) + + def THEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.THEN) + else: + return self.getToken(PLpgSQLParser.THEN, i) + + def ELSE(self): + return self.getToken(PLpgSQLParser.ELSE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_case_expression + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCase_expression" ): + listener.enterCase_expression(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCase_expression" ): + listener.exitCase_expression(self) + + + + + def case_expression(self): + + localctx = PLpgSQLParser.Case_expressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 576, self.RULE_case_expression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5827 + self.match(PLpgSQLParser.CASE) + self.state = 5829 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 5828 + self.vex(0) + + + self.state = 5836 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5831 + self.match(PLpgSQLParser.WHEN) + self.state = 5832 + self.vex(0) + self.state = 5833 + self.match(PLpgSQLParser.THEN) + self.state = 5834 + localctx._vex = self.vex(0) + localctx.r.append(localctx._vex) + self.state = 5838 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.WHEN): + break + + self.state = 5842 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ELSE: + self.state = 5840 + self.match(PLpgSQLParser.ELSE) + self.state = 5841 + localctx._vex = self.vex(0) + localctx.r.append(localctx._vex) + + + self.state = 5844 + self.match(PLpgSQLParser.END) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Cast_specificationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def CAST(self): + return self.getToken(PLpgSQLParser.CAST, 0) + + def TREAT(self): + return self.getToken(PLpgSQLParser.TREAT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_cast_specification + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCast_specification" ): + listener.enterCast_specification(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCast_specification" ): + listener.exitCast_specification(self) + + + + + def cast_specification(self): + + localctx = PLpgSQLParser.Cast_specificationContext(self, self._ctx, self.state) + self.enterRule(localctx, 578, self.RULE_cast_specification) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5846 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.TREAT or _la==PLpgSQLParser.CAST): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5847 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5848 + self.vex(0) + self.state = 5849 + self.match(PLpgSQLParser.AS) + self.state = 5850 + self.data_type() + self.state = 5851 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_callContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name_nontype(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_name_nontypeContext,0) + + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def vex_or_named_notation(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Vex_or_named_notationContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Vex_or_named_notationContext,i) + + + def WITHIN(self): + return self.getToken(PLpgSQLParser.WITHIN, 0) + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def orderby_clause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Orderby_clauseContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Orderby_clauseContext,i) + + + def filter_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Filter_clauseContext,0) + + + def OVER(self): + return self.getToken(PLpgSQLParser.OVER, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def window_definition(self): + return self.getTypedRuleContext(PLpgSQLParser.Window_definitionContext,0) + + + def set_qualifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_qualifierContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def function_construct(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_constructContext,0) + + + def extract_function(self): + return self.getTypedRuleContext(PLpgSQLParser.Extract_functionContext,0) + + + def system_function(self): + return self.getTypedRuleContext(PLpgSQLParser.System_functionContext,0) + + + def date_time_function(self): + return self.getTypedRuleContext(PLpgSQLParser.Date_time_functionContext,0) + + + def string_value_function(self): + return self.getTypedRuleContext(PLpgSQLParser.String_value_functionContext,0) + + + def xml_function(self): + return self.getTypedRuleContext(PLpgSQLParser.Xml_functionContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_call + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_call" ): + listener.enterFunction_call(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_call" ): + listener.exitFunction_call(self) + + + + + def function_call(self): + + localctx = PLpgSQLParser.Function_callContext(self, self._ctx, self.state) + self.enterRule(localctx, 580, self.RULE_function_call) + self._la = 0 # Token type + try: + self.state = 5896 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,736,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5853 + self.schema_qualified_name_nontype() + self.state = 5854 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5869 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.DISTINCT - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.VARIADIC - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 5856 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,728,self._ctx) + if la_ == 1: + self.state = 5855 + self.set_qualifier() + + + self.state = 5858 + self.vex_or_named_notation() + self.state = 5863 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5859 + self.match(PLpgSQLParser.COMMA) + self.state = 5860 + self.vex_or_named_notation() + self.state = 5865 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5867 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ORDER: + self.state = 5866 + self.orderby_clause() + + + + + self.state = 5871 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 5878 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,732,self._ctx) + if la_ == 1: + self.state = 5872 + self.match(PLpgSQLParser.WITHIN) + self.state = 5873 + self.match(PLpgSQLParser.GROUP) + self.state = 5874 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5875 + self.orderby_clause() + self.state = 5876 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 5881 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,733,self._ctx) + if la_ == 1: + self.state = 5880 + self.filter_clause() + + + self.state = 5888 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,735,self._ctx) + if la_ == 1: + self.state = 5883 + self.match(PLpgSQLParser.OVER) + self.state = 5886 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 5884 + self.identifier() + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 5885 + self.window_definition() + pass + else: + raise NoViableAltException(self) + + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5890 + self.function_construct() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5891 + self.extract_function() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5892 + self.system_function() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 5893 + self.date_time_function() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 5894 + self.string_value_function() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 5895 + self.xml_function() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Vex_or_named_notationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.argname = None # IdentifierContext + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def VARIADIC(self): + return self.getToken(PLpgSQLParser.VARIADIC, 0) + + def pointer(self): + return self.getTypedRuleContext(PLpgSQLParser.PointerContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_vex_or_named_notation + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVex_or_named_notation" ): + listener.enterVex_or_named_notation(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVex_or_named_notation" ): + listener.exitVex_or_named_notation(self) + + + + + def vex_or_named_notation(self): + + localctx = PLpgSQLParser.Vex_or_named_notationContext(self, self._ctx, self.state) + self.enterRule(localctx, 582, self.RULE_vex_or_named_notation) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5899 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.VARIADIC: + self.state = 5898 + self.match(PLpgSQLParser.VARIADIC) + + + self.state = 5904 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,738,self._ctx) + if la_ == 1: + self.state = 5901 + localctx.argname = self.identifier() + self.state = 5902 + self.pointer() + + + self.state = 5906 + self.vex(0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PointerContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EQUAL_GTH(self): + return self.getToken(PLpgSQLParser.EQUAL_GTH, 0) + + def COLON_EQUAL(self): + return self.getToken(PLpgSQLParser.COLON_EQUAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_pointer + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPointer" ): + listener.enterPointer(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPointer" ): + listener.exitPointer(self) + + + + + def pointer(self): + + localctx = PLpgSQLParser.PointerContext(self, self._ctx, self.state) + self.enterRule(localctx, 584, self.RULE_pointer) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5908 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.EQUAL_GTH or _la==PLpgSQLParser.COLON_EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_constructContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COALESCE(self): + return self.getToken(PLpgSQLParser.COALESCE, 0) + + def GREATEST(self): + return self.getToken(PLpgSQLParser.GREATEST, 0) + + def GROUPING(self): + return self.getToken(PLpgSQLParser.GROUPING, 0) + + def LEAST(self): + return self.getToken(PLpgSQLParser.LEAST, 0) + + def NULLIF(self): + return self.getToken(PLpgSQLParser.NULLIF, 0) + + def XMLCONCAT(self): + return self.getToken(PLpgSQLParser.XMLCONCAT, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_construct + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_construct" ): + listener.enterFunction_construct(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_construct" ): + listener.exitFunction_construct(self) + + + + + def function_construct(self): + + localctx = PLpgSQLParser.Function_constructContext(self, self._ctx, self.state) + self.enterRule(localctx, 586, self.RULE_function_construct) + self._la = 0 # Token type + try: + self.state = 5935 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.COALESCE, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.LEAST, PLpgSQLParser.NULLIF, PLpgSQLParser.XMLCONCAT]: + self.enterOuterAlt(localctx, 1) + self.state = 5910 + _la = self._input.LA(1) + if not(((((_la - 299)) & ~0x3f) == 0 and ((1 << (_la - 299)) & ((1 << (PLpgSQLParser.COALESCE - 299)) | (1 << (PLpgSQLParser.GREATEST - 299)) | (1 << (PLpgSQLParser.GROUPING - 299)) | (1 << (PLpgSQLParser.LEAST - 299)) | (1 << (PLpgSQLParser.NULLIF - 299)) | (1 << (PLpgSQLParser.XMLCONCAT - 299)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5911 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5912 + self.vex(0) + self.state = 5917 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5913 + self.match(PLpgSQLParser.COMMA) + self.state = 5914 + self.vex(0) + self.state = 5919 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5920 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.ROW]: + self.enterOuterAlt(localctx, 2) + self.state = 5922 + self.match(PLpgSQLParser.ROW) + self.state = 5923 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5932 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 5924 + self.vex(0) + self.state = 5929 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5925 + self.match(PLpgSQLParser.COMMA) + self.state = 5926 + self.vex(0) + self.state = 5931 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 5934 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Extract_functionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXTRACT(self): + return self.getToken(PLpgSQLParser.EXTRACT, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_extract_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExtract_function" ): + listener.enterExtract_function(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExtract_function" ): + listener.exitExtract_function(self) + + + + + def extract_function(self): + + localctx = PLpgSQLParser.Extract_functionContext(self, self._ctx, self.state) + self.enterRule(localctx, 588, self.RULE_extract_function) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5937 + self.match(PLpgSQLParser.EXTRACT) + self.state = 5938 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5941 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 5939 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 5940 + self.character_string() + pass + else: + raise NoViableAltException(self) + + self.state = 5943 + self.match(PLpgSQLParser.FROM) + self.state = 5944 + self.vex(0) + self.state = 5945 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class System_functionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CURRENT_CATALOG(self): + return self.getToken(PLpgSQLParser.CURRENT_CATALOG, 0) + + def CURRENT_SCHEMA(self): + return self.getToken(PLpgSQLParser.CURRENT_SCHEMA, 0) + + def CURRENT_USER(self): + return self.getToken(PLpgSQLParser.CURRENT_USER, 0) + + def SESSION_USER(self): + return self.getToken(PLpgSQLParser.SESSION_USER, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def cast_specification(self): + return self.getTypedRuleContext(PLpgSQLParser.Cast_specificationContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_system_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSystem_function" ): + listener.enterSystem_function(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSystem_function" ): + listener.exitSystem_function(self) + + + + + def system_function(self): + + localctx = PLpgSQLParser.System_functionContext(self, self._ctx, self.state) + self.enterRule(localctx, 590, self.RULE_system_function) + try: + self.state = 5953 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CURRENT_CATALOG]: + self.enterOuterAlt(localctx, 1) + self.state = 5947 + self.match(PLpgSQLParser.CURRENT_CATALOG) + pass + elif token in [PLpgSQLParser.CURRENT_SCHEMA]: + self.enterOuterAlt(localctx, 2) + self.state = 5948 + self.match(PLpgSQLParser.CURRENT_SCHEMA) + pass + elif token in [PLpgSQLParser.CURRENT_USER]: + self.enterOuterAlt(localctx, 3) + self.state = 5949 + self.match(PLpgSQLParser.CURRENT_USER) + pass + elif token in [PLpgSQLParser.SESSION_USER]: + self.enterOuterAlt(localctx, 4) + self.state = 5950 + self.match(PLpgSQLParser.SESSION_USER) + pass + elif token in [PLpgSQLParser.USER]: + self.enterOuterAlt(localctx, 5) + self.state = 5951 + self.match(PLpgSQLParser.USER) + pass + elif token in [PLpgSQLParser.TREAT, PLpgSQLParser.CAST]: + self.enterOuterAlt(localctx, 6) + self.state = 5952 + self.cast_specification() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Date_time_functionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CURRENT_DATE(self): + return self.getToken(PLpgSQLParser.CURRENT_DATE, 0) + + def CURRENT_TIME(self): + return self.getToken(PLpgSQLParser.CURRENT_TIME, 0) + + def type_length(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_lengthContext,0) + + + def CURRENT_TIMESTAMP(self): + return self.getToken(PLpgSQLParser.CURRENT_TIMESTAMP, 0) + + def LOCALTIME(self): + return self.getToken(PLpgSQLParser.LOCALTIME, 0) + + def LOCALTIMESTAMP(self): + return self.getToken(PLpgSQLParser.LOCALTIMESTAMP, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_date_time_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDate_time_function" ): + listener.enterDate_time_function(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDate_time_function" ): + listener.exitDate_time_function(self) + + + + + def date_time_function(self): + + localctx = PLpgSQLParser.Date_time_functionContext(self, self._ctx, self.state) + self.enterRule(localctx, 592, self.RULE_date_time_function) + try: + self.state = 5972 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CURRENT_DATE]: + self.enterOuterAlt(localctx, 1) + self.state = 5955 + self.match(PLpgSQLParser.CURRENT_DATE) + pass + elif token in [PLpgSQLParser.CURRENT_TIME]: + self.enterOuterAlt(localctx, 2) + self.state = 5956 + self.match(PLpgSQLParser.CURRENT_TIME) + self.state = 5958 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,745,self._ctx) + if la_ == 1: + self.state = 5957 + self.type_length() + + + pass + elif token in [PLpgSQLParser.CURRENT_TIMESTAMP]: + self.enterOuterAlt(localctx, 3) + self.state = 5960 + self.match(PLpgSQLParser.CURRENT_TIMESTAMP) + self.state = 5962 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,746,self._ctx) + if la_ == 1: + self.state = 5961 + self.type_length() + + + pass + elif token in [PLpgSQLParser.LOCALTIME]: + self.enterOuterAlt(localctx, 4) + self.state = 5964 + self.match(PLpgSQLParser.LOCALTIME) + self.state = 5966 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,747,self._ctx) + if la_ == 1: + self.state = 5965 + self.type_length() + + + pass + elif token in [PLpgSQLParser.LOCALTIMESTAMP]: + self.enterOuterAlt(localctx, 5) + self.state = 5968 + self.match(PLpgSQLParser.LOCALTIMESTAMP) + self.state = 5970 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,748,self._ctx) + if la_ == 1: + self.state = 5969 + self.type_length() + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class String_value_functionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.chars = None # VexContext + self.str = None # VexContext + + def TRIM(self): + return self.getToken(PLpgSQLParser.TRIM, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def LEADING(self): + return self.getToken(PLpgSQLParser.LEADING, 0) + + def TRAILING(self): + return self.getToken(PLpgSQLParser.TRAILING, 0) + + def BOTH(self): + return self.getToken(PLpgSQLParser.BOTH, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def SUBSTRING(self): + return self.getToken(PLpgSQLParser.SUBSTRING, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def POSITION(self): + return self.getToken(PLpgSQLParser.POSITION, 0) + + def vex_b(self): + return self.getTypedRuleContext(PLpgSQLParser.Vex_bContext,0) + + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def OVERLAY(self): + return self.getToken(PLpgSQLParser.OVERLAY, 0) + + def PLACING(self): + return self.getToken(PLpgSQLParser.PLACING, 0) + + def COLLATION(self): + return self.getToken(PLpgSQLParser.COLLATION, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_string_value_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterString_value_function" ): + listener.enterString_value_function(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitString_value_function" ): + listener.exitString_value_function(self) + + + + + def string_value_function(self): + + localctx = PLpgSQLParser.String_value_functionContext(self, self._ctx, self.state) + self.enterRule(localctx, 594, self.RULE_string_value_function) + self._la = 0 # Token type + try: + self.state = 6041 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.TRIM]: + self.enterOuterAlt(localctx, 1) + self.state = 5974 + self.match(PLpgSQLParser.TRIM) + self.state = 5975 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5977 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 375)) & ~0x3f) == 0 and ((1 << (_la - 375)) & ((1 << (PLpgSQLParser.BOTH - 375)) | (1 << (PLpgSQLParser.LEADING - 375)) | (1 << (PLpgSQLParser.TRAILING - 375)))) != 0): + self.state = 5976 + _la = self._input.LA(1) + if not(((((_la - 375)) & ~0x3f) == 0 and ((1 << (_la - 375)) & ((1 << (PLpgSQLParser.BOTH - 375)) | (1 << (PLpgSQLParser.LEADING - 375)) | (1 << (PLpgSQLParser.TRAILING - 375)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 5991 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,753,self._ctx) + if la_ == 1: + self.state = 5979 + localctx.chars = self.vex(0) + self.state = 5980 + self.match(PLpgSQLParser.FROM) + self.state = 5981 + localctx.str = self.vex(0) + pass + + elif la_ == 2: + self.state = 5984 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM: + self.state = 5983 + self.match(PLpgSQLParser.FROM) + + + self.state = 5986 + localctx.str = self.vex(0) + self.state = 5989 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 5987 + self.match(PLpgSQLParser.COMMA) + self.state = 5988 + localctx.chars = self.vex(0) + + + pass + + + self.state = 5993 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.SUBSTRING]: + self.enterOuterAlt(localctx, 2) + self.state = 5995 + self.match(PLpgSQLParser.SUBSTRING) + self.state = 5996 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 5997 + self.vex(0) + self.state = 6002 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 5998 + self.match(PLpgSQLParser.COMMA) + self.state = 5999 + self.vex(0) + self.state = 6004 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6007 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM: + self.state = 6005 + self.match(PLpgSQLParser.FROM) + self.state = 6006 + self.vex(0) + + + self.state = 6011 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 6009 + self.match(PLpgSQLParser.FOR) + self.state = 6010 + self.vex(0) + + + self.state = 6013 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.POSITION]: + self.enterOuterAlt(localctx, 3) + self.state = 6015 + self.match(PLpgSQLParser.POSITION) + self.state = 6016 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6017 + self.vex_b(0) + self.state = 6018 + self.match(PLpgSQLParser.IN) + self.state = 6019 + self.vex(0) + self.state = 6020 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.OVERLAY]: + self.enterOuterAlt(localctx, 4) + self.state = 6022 + self.match(PLpgSQLParser.OVERLAY) + self.state = 6023 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6024 + self.vex(0) + self.state = 6025 + self.match(PLpgSQLParser.PLACING) + self.state = 6026 + self.vex(0) + self.state = 6027 + self.match(PLpgSQLParser.FROM) + self.state = 6028 + self.vex(0) + self.state = 6031 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR: + self.state = 6029 + self.match(PLpgSQLParser.FOR) + self.state = 6030 + self.vex(0) + + + self.state = 6033 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.COLLATION]: + self.enterOuterAlt(localctx, 5) + self.state = 6035 + self.match(PLpgSQLParser.COLLATION) + self.state = 6036 + self.match(PLpgSQLParser.FOR) + self.state = 6037 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6038 + self.vex(0) + self.state = 6039 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Xml_functionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + self.attname = None # IdentifierContext + + def XMLELEMENT(self): + return self.getToken(PLpgSQLParser.XMLELEMENT, 0) + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def NAME(self): + return self.getToken(PLpgSQLParser.NAME, 0) + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def XMLATTRIBUTES(self): + return self.getToken(PLpgSQLParser.XMLATTRIBUTES, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def AS(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.AS) + else: + return self.getToken(PLpgSQLParser.AS, i) + + def XMLFOREST(self): + return self.getToken(PLpgSQLParser.XMLFOREST, 0) + + def XMLPI(self): + return self.getToken(PLpgSQLParser.XMLPI, 0) + + def XMLROOT(self): + return self.getToken(PLpgSQLParser.XMLROOT, 0) + + def VERSION(self): + return self.getToken(PLpgSQLParser.VERSION, 0) + + def NO(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.NO) + else: + return self.getToken(PLpgSQLParser.NO, i) + + def VALUE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.VALUE) + else: + return self.getToken(PLpgSQLParser.VALUE, i) + + def STANDALONE(self): + return self.getToken(PLpgSQLParser.STANDALONE, 0) + + def YES(self): + return self.getToken(PLpgSQLParser.YES, 0) + + def XMLEXISTS(self): + return self.getToken(PLpgSQLParser.XMLEXISTS, 0) + + def PASSING(self): + return self.getToken(PLpgSQLParser.PASSING, 0) + + def BY(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.BY) + else: + return self.getToken(PLpgSQLParser.BY, i) + + def REF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.REF) + else: + return self.getToken(PLpgSQLParser.REF, i) + + def XMLPARSE(self): + return self.getToken(PLpgSQLParser.XMLPARSE, 0) + + def DOCUMENT(self): + return self.getToken(PLpgSQLParser.DOCUMENT, 0) + + def CONTENT(self): + return self.getToken(PLpgSQLParser.CONTENT, 0) + + def XMLSERIALIZE(self): + return self.getToken(PLpgSQLParser.XMLSERIALIZE, 0) + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def XMLTABLE(self): + return self.getToken(PLpgSQLParser.XMLTABLE, 0) + + def COLUMNS(self): + return self.getToken(PLpgSQLParser.COLUMNS, 0) + + def xml_table_column(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Xml_table_columnContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Xml_table_columnContext,i) + + + def XMLNAMESPACES(self): + return self.getToken(PLpgSQLParser.XMLNAMESPACES, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_xml_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterXml_function" ): + listener.enterXml_function(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitXml_function" ): + listener.exitXml_function(self) + + + + + def xml_function(self): + + localctx = PLpgSQLParser.Xml_functionContext(self, self._ctx, self.state) + self.enterRule(localctx, 596, self.RULE_xml_function) + self._la = 0 # Token type + try: + self.state = 6204 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.XMLELEMENT]: + self.enterOuterAlt(localctx, 1) + self.state = 6043 + self.match(PLpgSQLParser.XMLELEMENT) + self.state = 6044 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6045 + self.match(PLpgSQLParser.NAME) + self.state = 6046 + localctx.name = self.identifier() + self.state = 6068 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,762,self._ctx) + if la_ == 1: + self.state = 6047 + self.match(PLpgSQLParser.COMMA) + self.state = 6048 + self.match(PLpgSQLParser.XMLATTRIBUTES) + self.state = 6049 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6050 + self.vex(0) + self.state = 6053 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6051 + self.match(PLpgSQLParser.AS) + self.state = 6052 + localctx.attname = self.identifier() + + + self.state = 6063 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6055 + self.match(PLpgSQLParser.COMMA) + self.state = 6056 + self.vex(0) + self.state = 6059 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6057 + self.match(PLpgSQLParser.AS) + self.state = 6058 + localctx.attname = self.identifier() + + + self.state = 6065 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6066 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 6074 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6070 + self.match(PLpgSQLParser.COMMA) + self.state = 6071 + self.vex(0) + self.state = 6076 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6077 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLFOREST]: + self.enterOuterAlt(localctx, 2) + self.state = 6079 + self.match(PLpgSQLParser.XMLFOREST) + self.state = 6080 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6081 + self.vex(0) + self.state = 6084 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6082 + self.match(PLpgSQLParser.AS) + self.state = 6083 + localctx.name = self.identifier() + + + self.state = 6094 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6086 + self.match(PLpgSQLParser.COMMA) + self.state = 6087 + self.vex(0) + self.state = 6090 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6088 + self.match(PLpgSQLParser.AS) + self.state = 6089 + localctx.name = self.identifier() + + + self.state = 6096 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6097 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLPI]: + self.enterOuterAlt(localctx, 3) + self.state = 6099 + self.match(PLpgSQLParser.XMLPI) + self.state = 6100 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6101 + self.match(PLpgSQLParser.NAME) + self.state = 6102 + localctx.name = self.identifier() + self.state = 6105 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 6103 + self.match(PLpgSQLParser.COMMA) + self.state = 6104 + self.vex(0) + + + self.state = 6107 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLROOT]: + self.enterOuterAlt(localctx, 4) + self.state = 6109 + self.match(PLpgSQLParser.XMLROOT) + self.state = 6110 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6111 + self.vex(0) + self.state = 6112 + self.match(PLpgSQLParser.COMMA) + self.state = 6113 + self.match(PLpgSQLParser.VERSION) + self.state = 6117 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,768,self._ctx) + if la_ == 1: + self.state = 6114 + self.vex(0) + pass + + elif la_ == 2: + self.state = 6115 + self.match(PLpgSQLParser.NO) + self.state = 6116 + self.match(PLpgSQLParser.VALUE) + pass + + + self.state = 6127 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 6119 + self.match(PLpgSQLParser.COMMA) + self.state = 6120 + self.match(PLpgSQLParser.STANDALONE) + self.state = 6125 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,769,self._ctx) + if la_ == 1: + self.state = 6121 + self.match(PLpgSQLParser.YES) + pass + + elif la_ == 2: + self.state = 6122 + self.match(PLpgSQLParser.NO) + pass + + elif la_ == 3: + self.state = 6123 + self.match(PLpgSQLParser.NO) + self.state = 6124 + self.match(PLpgSQLParser.VALUE) + pass + + + + + self.state = 6129 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLEXISTS]: + self.enterOuterAlt(localctx, 5) + self.state = 6131 + self.match(PLpgSQLParser.XMLEXISTS) + self.state = 6132 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6133 + self.vex(0) + self.state = 6134 + self.match(PLpgSQLParser.PASSING) + self.state = 6137 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,771,self._ctx) + if la_ == 1: + self.state = 6135 + self.match(PLpgSQLParser.BY) + self.state = 6136 + self.match(PLpgSQLParser.REF) + + + self.state = 6139 + self.vex(0) + self.state = 6142 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BY: + self.state = 6140 + self.match(PLpgSQLParser.BY) + self.state = 6141 + self.match(PLpgSQLParser.REF) + + + self.state = 6144 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLPARSE]: + self.enterOuterAlt(localctx, 6) + self.state = 6146 + self.match(PLpgSQLParser.XMLPARSE) + self.state = 6147 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6148 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONTENT or _la==PLpgSQLParser.DOCUMENT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6149 + self.vex(0) + self.state = 6150 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLSERIALIZE]: + self.enterOuterAlt(localctx, 7) + self.state = 6152 + self.match(PLpgSQLParser.XMLSERIALIZE) + self.state = 6153 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6154 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONTENT or _la==PLpgSQLParser.DOCUMENT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6155 + self.vex(0) + self.state = 6156 + self.match(PLpgSQLParser.AS) + self.state = 6157 + self.data_type() + self.state = 6158 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.XMLTABLE]: + self.enterOuterAlt(localctx, 8) + self.state = 6160 + self.match(PLpgSQLParser.XMLTABLE) + self.state = 6161 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6180 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,774,self._ctx) + if la_ == 1: + self.state = 6162 + self.match(PLpgSQLParser.XMLNAMESPACES) + self.state = 6163 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6164 + self.vex(0) + self.state = 6165 + self.match(PLpgSQLParser.AS) + self.state = 6166 + localctx.name = self.identifier() + self.state = 6174 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6167 + self.match(PLpgSQLParser.COMMA) + self.state = 6168 + self.vex(0) + self.state = 6169 + self.match(PLpgSQLParser.AS) + self.state = 6170 + localctx.name = self.identifier() + self.state = 6176 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6177 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 6178 + self.match(PLpgSQLParser.COMMA) + + + self.state = 6182 + self.vex(0) + self.state = 6183 + self.match(PLpgSQLParser.PASSING) + self.state = 6186 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,775,self._ctx) + if la_ == 1: + self.state = 6184 + self.match(PLpgSQLParser.BY) + self.state = 6185 + self.match(PLpgSQLParser.REF) + + + self.state = 6188 + self.vex(0) + self.state = 6191 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BY: + self.state = 6189 + self.match(PLpgSQLParser.BY) + self.state = 6190 + self.match(PLpgSQLParser.REF) + + + self.state = 6193 + self.match(PLpgSQLParser.COLUMNS) + self.state = 6194 + self.xml_table_column() + self.state = 6199 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6195 + self.match(PLpgSQLParser.COMMA) + self.state = 6196 + self.xml_table_column() + self.state = 6201 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6202 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Xml_table_columnContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.name = None # IdentifierContext + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def ORDINALITY(self): + return self.getToken(PLpgSQLParser.ORDINALITY, 0) + + def PATH(self): + return self.getToken(PLpgSQLParser.PATH, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_xml_table_column + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterXml_table_column" ): + listener.enterXml_table_column(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitXml_table_column" ): + listener.exitXml_table_column(self) + + + + + def xml_table_column(self): + + localctx = PLpgSQLParser.Xml_table_columnContext(self, self._ctx, self.state) + self.enterRule(localctx, 598, self.RULE_xml_table_column) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6206 + localctx.name = self.identifier() + self.state = 6224 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 6207 + self.data_type() + self.state = 6210 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PATH: + self.state = 6208 + self.match(PLpgSQLParser.PATH) + self.state = 6209 + self.vex(0) + + + self.state = 6214 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFAULT: + self.state = 6212 + self.match(PLpgSQLParser.DEFAULT) + self.state = 6213 + self.vex(0) + + + self.state = 6220 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT or _la==PLpgSQLParser.NULL: + self.state = 6217 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 6216 + self.match(PLpgSQLParser.NOT) + + + self.state = 6219 + self.match(PLpgSQLParser.NULL) + + + pass + elif token in [PLpgSQLParser.FOR]: + self.state = 6222 + self.match(PLpgSQLParser.FOR) + self.state = 6223 + self.match(PLpgSQLParser.ORDINALITY) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Comparison_modContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def ANY(self): + return self.getToken(PLpgSQLParser.ANY, 0) + + def SOME(self): + return self.getToken(PLpgSQLParser.SOME, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def select_stmt_no_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmt_no_parensContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_comparison_mod + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComparison_mod" ): + listener.enterComparison_mod(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComparison_mod" ): + listener.exitComparison_mod(self) + + + + + def comparison_mod(self): + + localctx = PLpgSQLParser.Comparison_modContext(self, self._ctx, self.state) + self.enterRule(localctx, 600, self.RULE_comparison_mod) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6226 + _la = self._input.LA(1) + if not(((((_la - 366)) & ~0x3f) == 0 and ((1 << (_la - 366)) & ((1 << (PLpgSQLParser.ALL - 366)) | (1 << (PLpgSQLParser.ANY - 366)) | (1 << (PLpgSQLParser.SOME - 366)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6227 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6230 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,784,self._ctx) + if la_ == 1: + self.state = 6228 + self.vex(0) + pass + + elif la_ == 2: + self.state = 6229 + self.select_stmt_no_parens() + pass + + + self.state = 6232 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Filter_clauseContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FILTER(self): + return self.getToken(PLpgSQLParser.FILTER, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_filter_clause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFilter_clause" ): + listener.enterFilter_clause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFilter_clause" ): + listener.exitFilter_clause(self) + + + + + def filter_clause(self): + + localctx = PLpgSQLParser.Filter_clauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 602, self.RULE_filter_clause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6234 + self.match(PLpgSQLParser.FILTER) + self.state = 6235 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6236 + self.match(PLpgSQLParser.WHERE) + self.state = 6237 + self.vex(0) + self.state = 6238 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Window_definitionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def partition_by_columns(self): + return self.getTypedRuleContext(PLpgSQLParser.Partition_by_columnsContext,0) + + + def orderby_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Orderby_clauseContext,0) + + + def frame_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Frame_clauseContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_window_definition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWindow_definition" ): + listener.enterWindow_definition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWindow_definition" ): + listener.exitWindow_definition(self) + + + + + def window_definition(self): + + localctx = PLpgSQLParser.Window_definitionContext(self, self._ctx, self.state) + self.enterRule(localctx, 604, self.RULE_window_definition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6240 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6242 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,785,self._ctx) + if la_ == 1: + self.state = 6241 + self.identifier() + + + self.state = 6245 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.PARTITION: + self.state = 6244 + self.partition_by_columns() + + + self.state = 6248 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ORDER: + self.state = 6247 + self.orderby_clause() + + + self.state = 6251 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GROUPS or _la==PLpgSQLParser.RANGE or _la==PLpgSQLParser.ROWS: + self.state = 6250 + self.frame_clause() + + + self.state = 6253 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Frame_clauseContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RANGE(self): + return self.getToken(PLpgSQLParser.RANGE, 0) + + def ROWS(self): + return self.getToken(PLpgSQLParser.ROWS, 0) + + def GROUPS(self): + return self.getToken(PLpgSQLParser.GROUPS, 0) + + def frame_bound(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Frame_boundContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Frame_boundContext,i) + + + def BETWEEN(self): + return self.getToken(PLpgSQLParser.BETWEEN, 0) + + def AND(self): + return self.getToken(PLpgSQLParser.AND, 0) + + def EXCLUDE(self): + return self.getToken(PLpgSQLParser.EXCLUDE, 0) + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def TIES(self): + return self.getToken(PLpgSQLParser.TIES, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def OTHERS(self): + return self.getToken(PLpgSQLParser.OTHERS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_frame_clause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFrame_clause" ): + listener.enterFrame_clause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFrame_clause" ): + listener.exitFrame_clause(self) + + + + + def frame_clause(self): + + localctx = PLpgSQLParser.Frame_clauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 606, self.RULE_frame_clause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6255 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.GROUPS or _la==PLpgSQLParser.RANGE or _la==PLpgSQLParser.ROWS): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6262 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,789,self._ctx) + if la_ == 1: + self.state = 6256 + self.frame_bound() + pass + + elif la_ == 2: + self.state = 6257 + self.match(PLpgSQLParser.BETWEEN) + self.state = 6258 + self.frame_bound() + self.state = 6259 + self.match(PLpgSQLParser.AND) + self.state = 6260 + self.frame_bound() + pass + + + self.state = 6273 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.EXCLUDE: + self.state = 6264 + self.match(PLpgSQLParser.EXCLUDE) + self.state = 6271 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.CURRENT]: + self.state = 6265 + self.match(PLpgSQLParser.CURRENT) + self.state = 6266 + self.match(PLpgSQLParser.ROW) + pass + elif token in [PLpgSQLParser.GROUP]: + self.state = 6267 + self.match(PLpgSQLParser.GROUP) + pass + elif token in [PLpgSQLParser.TIES]: + self.state = 6268 + self.match(PLpgSQLParser.TIES) + pass + elif token in [PLpgSQLParser.NO]: + self.state = 6269 + self.match(PLpgSQLParser.NO) + self.state = 6270 + self.match(PLpgSQLParser.OTHERS) + pass + else: + raise NoViableAltException(self) + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Frame_boundContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def PRECEDING(self): + return self.getToken(PLpgSQLParser.PRECEDING, 0) + + def FOLLOWING(self): + return self.getToken(PLpgSQLParser.FOLLOWING, 0) + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_frame_bound + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFrame_bound" ): + listener.enterFrame_bound(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFrame_bound" ): + listener.exitFrame_bound(self) + + + + + def frame_bound(self): + + localctx = PLpgSQLParser.Frame_boundContext(self, self._ctx, self.state) + self.enterRule(localctx, 608, self.RULE_frame_bound) + self._la = 0 # Token type + try: + self.state = 6280 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,792,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6275 + self.vex(0) + self.state = 6276 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FOLLOWING or _la==PLpgSQLParser.PRECEDING): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6278 + self.match(PLpgSQLParser.CURRENT) + self.state = 6279 + self.match(PLpgSQLParser.ROW) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Array_expressionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ARRAY(self): + return self.getToken(PLpgSQLParser.ARRAY, 0) + + def array_elements(self): + return self.getTypedRuleContext(PLpgSQLParser.Array_elementsContext,0) + + + def table_subquery(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_subqueryContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_array_expression + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArray_expression" ): + listener.enterArray_expression(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArray_expression" ): + listener.exitArray_expression(self) + + + + + def array_expression(self): + + localctx = PLpgSQLParser.Array_expressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 610, self.RULE_array_expression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6282 + self.match(PLpgSQLParser.ARRAY) + self.state = 6285 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_BRACKET]: + self.state = 6283 + self.array_elements() + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 6284 + self.table_subquery() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Array_elementsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_BRACKET(self): + return self.getToken(PLpgSQLParser.LEFT_BRACKET, 0) + + def RIGHT_BRACKET(self): + return self.getToken(PLpgSQLParser.RIGHT_BRACKET, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def array_elements(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Array_elementsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Array_elementsContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_array_elements + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArray_elements" ): + listener.enterArray_elements(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArray_elements" ): + listener.exitArray_elements(self) + + + + + def array_elements(self): + + localctx = PLpgSQLParser.Array_elementsContext(self, self._ctx, self.state) + self.enterRule(localctx, 612, self.RULE_array_elements) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6287 + self.match(PLpgSQLParser.LEFT_BRACKET) + self.state = 6302 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LEFT_BRACKET - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 6290 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 6288 + self.vex(0) + pass + elif token in [PLpgSQLParser.LEFT_BRACKET]: + self.state = 6289 + self.array_elements() + pass + else: + raise NoViableAltException(self) + + self.state = 6299 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6292 + self.match(PLpgSQLParser.COMMA) + self.state = 6295 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 6293 + self.vex(0) + pass + elif token in [PLpgSQLParser.LEFT_BRACKET]: + self.state = 6294 + self.array_elements() + pass + else: + raise NoViableAltException(self) + + self.state = 6301 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 6304 + self.match(PLpgSQLParser.RIGHT_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Type_coercionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def INTERVAL(self): + return self.getToken(PLpgSQLParser.INTERVAL, 0) + + def interval_field(self): + return self.getTypedRuleContext(PLpgSQLParser.Interval_fieldContext,0) + + + def type_length(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_lengthContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_type_coercion + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterType_coercion" ): + listener.enterType_coercion(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitType_coercion" ): + listener.exitType_coercion(self) + + + + + def type_coercion(self): + + localctx = PLpgSQLParser.Type_coercionContext(self, self._ctx, self.state) + self.enterRule(localctx, 614, self.RULE_type_coercion) + try: + self.state = 6315 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,799,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6306 + self.data_type() + self.state = 6307 + self.character_string() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6309 + self.match(PLpgSQLParser.INTERVAL) + self.state = 6310 + self.character_string() + self.state = 6311 + self.interval_field() + self.state = 6313 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,798,self._ctx) + if la_ == 1: + self.state = 6312 + self.type_length() + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Schema_qualified_nameContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def DOT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DOT) + else: + return self.getToken(PLpgSQLParser.DOT, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_schema_qualified_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSchema_qualified_name" ): + listener.enterSchema_qualified_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSchema_qualified_name" ): + listener.exitSchema_qualified_name(self) + + + + + def schema_qualified_name(self): + + localctx = PLpgSQLParser.Schema_qualified_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 616, self.RULE_schema_qualified_name) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6317 + self.identifier() + self.state = 6324 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,801,self._ctx) + if la_ == 1: + self.state = 6318 + self.match(PLpgSQLParser.DOT) + self.state = 6319 + self.identifier() + self.state = 6322 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,800,self._ctx) + if la_ == 1: + self.state = 6320 + self.match(PLpgSQLParser.DOT) + self.state = 6321 + self.identifier() + + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Set_qualifierContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISTINCT(self): + return self.getToken(PLpgSQLParser.DISTINCT, 0) + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_set_qualifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet_qualifier" ): + listener.enterSet_qualifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet_qualifier" ): + listener.exitSet_qualifier(self) + + + + + def set_qualifier(self): + + localctx = PLpgSQLParser.Set_qualifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 618, self.RULE_set_qualifier) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6326 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ALL or _la==PLpgSQLParser.DISTINCT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Table_subqueryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_table_subquery + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTable_subquery" ): + listener.enterTable_subquery(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTable_subquery" ): + listener.exitTable_subquery(self) + + + + + def table_subquery(self): + + localctx = PLpgSQLParser.Table_subqueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 620, self.RULE_table_subquery) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6328 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6329 + self.select_stmt() + self.state = 6330 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Select_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_ops(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_opsContext,0) + + + def with_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.With_clauseContext,0) + + + def after_ops(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.After_opsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.After_opsContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_stmt" ): + listener.enterSelect_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_stmt" ): + listener.exitSelect_stmt(self) + + + + + def select_stmt(self): + + localctx = PLpgSQLParser.Select_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 622, self.RULE_select_stmt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6333 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 6332 + self.with_clause() + + + self.state = 6335 + self.select_ops(0) + self.state = 6339 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 398)) & ~0x3f) == 0 and ((1 << (_la - 398)) & ((1 << (PLpgSQLParser.FETCH - 398)) | (1 << (PLpgSQLParser.FOR - 398)) | (1 << (PLpgSQLParser.LIMIT - 398)) | (1 << (PLpgSQLParser.OFFSET - 398)) | (1 << (PLpgSQLParser.ORDER - 398)))) != 0): + self.state = 6336 + self.after_ops() + self.state = 6341 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class After_opsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def orderby_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Orderby_clauseContext,0) + + + def LIMIT(self): + return self.getToken(PLpgSQLParser.LIMIT, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def ALL(self): + return self.getToken(PLpgSQLParser.ALL, 0) + + def OFFSET(self): + return self.getToken(PLpgSQLParser.OFFSET, 0) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def ROWS(self): + return self.getToken(PLpgSQLParser.ROWS, 0) + + def FETCH(self): + return self.getToken(PLpgSQLParser.FETCH, 0) + + def FIRST(self): + return self.getToken(PLpgSQLParser.FIRST, 0) + + def NEXT(self): + return self.getToken(PLpgSQLParser.NEXT, 0) + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def KEY(self): + return self.getToken(PLpgSQLParser.KEY, 0) + + def SHARE(self): + return self.getToken(PLpgSQLParser.SHARE, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def schema_qualified_name(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Schema_qualified_nameContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,i) + + + def NOWAIT(self): + return self.getToken(PLpgSQLParser.NOWAIT, 0) + + def SKIP_(self): + return self.getToken(PLpgSQLParser.SKIP_, 0) + + def LOCKED(self): + return self.getToken(PLpgSQLParser.LOCKED, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_after_ops + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAfter_ops" ): + listener.enterAfter_ops(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAfter_ops" ): + listener.exitAfter_ops(self) + + + + + def after_ops(self): + + localctx = PLpgSQLParser.After_opsContext(self, self._ctx, self.state) + self.enterRule(localctx, 624, self.RULE_after_ops) + self._la = 0 # Token type + try: + self.state = 6388 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ORDER]: + self.enterOuterAlt(localctx, 1) + self.state = 6342 + self.orderby_clause() + pass + elif token in [PLpgSQLParser.LIMIT]: + self.enterOuterAlt(localctx, 2) + self.state = 6343 + self.match(PLpgSQLParser.LIMIT) + self.state = 6346 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,804,self._ctx) + if la_ == 1: + self.state = 6344 + self.vex(0) + pass + + elif la_ == 2: + self.state = 6345 + self.match(PLpgSQLParser.ALL) + pass + + + pass + elif token in [PLpgSQLParser.OFFSET]: + self.enterOuterAlt(localctx, 3) + self.state = 6348 + self.match(PLpgSQLParser.OFFSET) + self.state = 6349 + self.vex(0) + self.state = 6351 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ROWS or _la==PLpgSQLParser.ROW: + self.state = 6350 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ROWS or _la==PLpgSQLParser.ROW): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + pass + elif token in [PLpgSQLParser.FETCH]: + self.enterOuterAlt(localctx, 4) + self.state = 6353 + self.match(PLpgSQLParser.FETCH) + self.state = 6354 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FIRST or _la==PLpgSQLParser.NEXT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6356 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,806,self._ctx) + if la_ == 1: + self.state = 6355 + self.vex(0) + + + self.state = 6358 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ROWS or _la==PLpgSQLParser.ROW): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6360 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 6359 + self.match(PLpgSQLParser.ONLY) + + + pass + elif token in [PLpgSQLParser.FOR]: + self.enterOuterAlt(localctx, 5) + self.state = 6362 + self.match(PLpgSQLParser.FOR) + self.state = 6370 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.UPDATE]: + self.state = 6363 + self.match(PLpgSQLParser.UPDATE) + pass + elif token in [PLpgSQLParser.NO]: + self.state = 6364 + self.match(PLpgSQLParser.NO) + self.state = 6365 + self.match(PLpgSQLParser.KEY) + self.state = 6366 + self.match(PLpgSQLParser.UPDATE) + pass + elif token in [PLpgSQLParser.SHARE]: + self.state = 6367 + self.match(PLpgSQLParser.SHARE) + pass + elif token in [PLpgSQLParser.KEY]: + self.state = 6368 + self.match(PLpgSQLParser.KEY) + self.state = 6369 + self.match(PLpgSQLParser.SHARE) + pass + else: + raise NoViableAltException(self) + + self.state = 6381 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OF: + self.state = 6372 + self.match(PLpgSQLParser.OF) + self.state = 6373 + self.schema_qualified_name() + self.state = 6378 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6374 + self.match(PLpgSQLParser.COMMA) + self.state = 6375 + self.schema_qualified_name() + self.state = 6380 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 6386 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.NOWAIT]: + self.state = 6383 + self.match(PLpgSQLParser.NOWAIT) + pass + elif token in [PLpgSQLParser.SKIP_]: + self.state = 6384 + self.match(PLpgSQLParser.SKIP_) + self.state = 6385 + self.match(PLpgSQLParser.LOCKED) + pass + elif token in [PLpgSQLParser.EOF, PLpgSQLParser.FETCH, PLpgSQLParser.FOR, PLpgSQLParser.LIMIT, PLpgSQLParser.OFFSET, PLpgSQLParser.ON, PLpgSQLParser.ORDER, PLpgSQLParser.RETURNING, PLpgSQLParser.WITH, PLpgSQLParser.LOOP, PLpgSQLParser.SEMI_COLON, PLpgSQLParser.RIGHT_PAREN]: + pass + else: + pass + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Select_stmt_no_parensContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_ops_no_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_ops_no_parensContext,0) + + + def with_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.With_clauseContext,0) + + + def after_ops(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.After_opsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.After_opsContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_stmt_no_parens + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_stmt_no_parens" ): + listener.enterSelect_stmt_no_parens(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_stmt_no_parens" ): + listener.exitSelect_stmt_no_parens(self) + + + + + def select_stmt_no_parens(self): + + localctx = PLpgSQLParser.Select_stmt_no_parensContext(self, self._ctx, self.state) + self.enterRule(localctx, 626, self.RULE_select_stmt_no_parens) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6391 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 6390 + self.with_clause() + + + self.state = 6393 + self.select_ops_no_parens() + self.state = 6397 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 398)) & ~0x3f) == 0 and ((1 << (_la - 398)) & ((1 << (PLpgSQLParser.FETCH - 398)) | (1 << (PLpgSQLParser.FOR - 398)) | (1 << (PLpgSQLParser.LIMIT - 398)) | (1 << (PLpgSQLParser.OFFSET - 398)) | (1 << (PLpgSQLParser.ORDER - 398)))) != 0): + self.state = 6394 + self.after_ops() + self.state = 6399 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class With_clauseContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def with_query(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.With_queryContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.With_queryContext,i) + + + def RECURSIVE(self): + return self.getToken(PLpgSQLParser.RECURSIVE, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_with_clause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWith_clause" ): + listener.enterWith_clause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWith_clause" ): + listener.exitWith_clause(self) + + + + + def with_clause(self): + + localctx = PLpgSQLParser.With_clauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 628, self.RULE_with_clause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6400 + self.match(PLpgSQLParser.WITH) + self.state = 6402 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,815,self._ctx) + if la_ == 1: + self.state = 6401 + self.match(PLpgSQLParser.RECURSIVE) + + + self.state = 6404 + self.with_query() + self.state = 6409 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6405 + self.match(PLpgSQLParser.COMMA) + self.state = 6406 + self.with_query() + self.state = 6411 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class With_queryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.query_name = None # IdentifierContext + self._identifier = None # IdentifierContext + self.column_name = list() # of IdentifierContexts + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def data_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_statementContext,0) + + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def MATERIALIZED(self): + return self.getToken(PLpgSQLParser.MATERIALIZED, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_with_query + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWith_query" ): + listener.enterWith_query(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWith_query" ): + listener.exitWith_query(self) + + + + + def with_query(self): + + localctx = PLpgSQLParser.With_queryContext(self, self._ctx, self.state) + self.enterRule(localctx, 630, self.RULE_with_query) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6412 + localctx.query_name = self.identifier() + self.state = 6424 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 6413 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6414 + localctx._identifier = self.identifier() + localctx.column_name.append(localctx._identifier) + self.state = 6419 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6415 + self.match(PLpgSQLParser.COMMA) + self.state = 6416 + localctx._identifier = self.identifier() + localctx.column_name.append(localctx._identifier) + self.state = 6421 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6422 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 6426 + self.match(PLpgSQLParser.AS) + self.state = 6431 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MATERIALIZED or _la==PLpgSQLParser.NOT: + self.state = 6428 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 6427 + self.match(PLpgSQLParser.NOT) + + + self.state = 6430 + self.match(PLpgSQLParser.MATERIALIZED) + + + self.state = 6433 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6434 + self.data_statement() + self.state = 6435 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Select_opsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def select_primary(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_primaryContext,0) + + + def select_ops(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Select_opsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Select_opsContext,i) + + + def INTERSECT(self): + return self.getToken(PLpgSQLParser.INTERSECT, 0) + + def UNION(self): + return self.getToken(PLpgSQLParser.UNION, 0) + + def EXCEPT(self): + return self.getToken(PLpgSQLParser.EXCEPT, 0) + + def set_qualifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_qualifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_ops + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_ops" ): + listener.enterSelect_ops(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_ops" ): + listener.exitSelect_ops(self) + + + + def select_ops(self, _p:int=0): + _parentctx = self._ctx + _parentState = self.state + localctx = PLpgSQLParser.Select_opsContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 632 + self.enterRecursionRule(localctx, 632, self.RULE_select_ops, _p) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6443 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 6438 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6439 + self.select_stmt() + self.state = 6440 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + elif token in [PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE]: + self.state = 6442 + self.select_primary() + pass + else: + raise NoViableAltException(self) + + self._ctx.stop = self._input.LT(-1) + self.state = 6453 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,823,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + localctx = PLpgSQLParser.Select_opsContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_select_ops) + self.state = 6445 + if not self.precpred(self._ctx, 2): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + self.state = 6446 + _la = self._input.LA(1) + if not(((((_la - 396)) & ~0x3f) == 0 and ((1 << (_la - 396)) & ((1 << (PLpgSQLParser.EXCEPT - 396)) | (1 << (PLpgSQLParser.INTERSECT - 396)) | (1 << (PLpgSQLParser.UNION - 396)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6448 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALL or _la==PLpgSQLParser.DISTINCT: + self.state = 6447 + self.set_qualifier() + + + self.state = 6450 + self.select_ops(3) + self.state = 6455 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,823,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + + class Select_ops_no_parensContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_ops(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_opsContext,0) + + + def INTERSECT(self): + return self.getToken(PLpgSQLParser.INTERSECT, 0) + + def UNION(self): + return self.getToken(PLpgSQLParser.UNION, 0) + + def EXCEPT(self): + return self.getToken(PLpgSQLParser.EXCEPT, 0) + + def select_primary(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_primaryContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def set_qualifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_qualifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_ops_no_parens + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_ops_no_parens" ): + listener.enterSelect_ops_no_parens(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_ops_no_parens" ): + listener.exitSelect_ops_no_parens(self) + + + + + def select_ops_no_parens(self): + + localctx = PLpgSQLParser.Select_ops_no_parensContext(self, self._ctx, self.state) + self.enterRule(localctx, 634, self.RULE_select_ops_no_parens) + self._la = 0 # Token type + try: + self.state = 6469 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,826,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6456 + self.select_ops(0) + self.state = 6457 + _la = self._input.LA(1) + if not(((((_la - 396)) & ~0x3f) == 0 and ((1 << (_la - 396)) & ((1 << (PLpgSQLParser.EXCEPT - 396)) | (1 << (PLpgSQLParser.INTERSECT - 396)) | (1 << (PLpgSQLParser.UNION - 396)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6459 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALL or _la==PLpgSQLParser.DISTINCT: + self.state = 6458 + self.set_qualifier() + + + self.state = 6466 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE]: + self.state = 6461 + self.select_primary() + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.state = 6462 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6463 + self.select_stmt() + self.state = 6464 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6468 + self.select_primary() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Select_primaryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SELECT(self): + return self.getToken(PLpgSQLParser.SELECT, 0) + + def set_qualifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Set_qualifierContext,0) + + + def select_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_listContext,0) + + + def into_table(self): + return self.getTypedRuleContext(PLpgSQLParser.Into_tableContext,0) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def from_item(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.From_itemContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.From_itemContext,i) + + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def groupby_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Groupby_clauseContext,0) + + + def HAVING(self): + return self.getToken(PLpgSQLParser.HAVING, 0) + + def WINDOW(self): + return self.getToken(PLpgSQLParser.WINDOW, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def AS(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.AS) + else: + return self.getToken(PLpgSQLParser.AS, i) + + def window_definition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Window_definitionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Window_definitionContext,i) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def values_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Values_stmtContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_primary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_primary" ): + listener.enterSelect_primary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_primary" ): + listener.exitSelect_primary(self) + + + + + def select_primary(self): + + localctx = PLpgSQLParser.Select_primaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 636, self.RULE_select_primary) + self._la = 0 # Token type + try: + self.state = 6542 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.SELECT]: + self.enterOuterAlt(localctx, 1) + self.state = 6471 + self.match(PLpgSQLParser.SELECT) + self.state = 6487 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,829,self._ctx) + if la_ == 1: + self.state = 6472 + self.set_qualifier() + self.state = 6485 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,828,self._ctx) + if la_ == 1: + self.state = 6473 + self.match(PLpgSQLParser.ON) + self.state = 6474 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6475 + self.vex(0) + self.state = 6480 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6476 + self.match(PLpgSQLParser.COMMA) + self.state = 6477 + self.vex(0) + self.state = 6482 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6483 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + + + self.state = 6490 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,830,self._ctx) + if la_ == 1: + self.state = 6489 + self.select_list() + + + self.state = 6493 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,831,self._ctx) + if la_ == 1: + self.state = 6492 + self.into_table() + + + self.state = 6504 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,833,self._ctx) + if la_ == 1: + self.state = 6495 + self.match(PLpgSQLParser.FROM) + self.state = 6496 + self.from_item(0) + self.state = 6501 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,832,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 6497 + self.match(PLpgSQLParser.COMMA) + self.state = 6498 + self.from_item(0) + self.state = 6503 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,832,self._ctx) + + + + self.state = 6508 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,834,self._ctx) + if la_ == 1: + self.state = 6506 + self.match(PLpgSQLParser.WHERE) + self.state = 6507 + self.vex(0) + + + self.state = 6511 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,835,self._ctx) + if la_ == 1: + self.state = 6510 + self.groupby_clause() + + + self.state = 6515 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,836,self._ctx) + if la_ == 1: + self.state = 6513 + self.match(PLpgSQLParser.HAVING) + self.state = 6514 + self.vex(0) + + + self.state = 6531 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,838,self._ctx) + if la_ == 1: + self.state = 6517 + self.match(PLpgSQLParser.WINDOW) + self.state = 6518 + self.identifier() + self.state = 6519 + self.match(PLpgSQLParser.AS) + self.state = 6520 + self.window_definition() + self.state = 6528 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,837,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 6521 + self.match(PLpgSQLParser.COMMA) + self.state = 6522 + self.identifier() + self.state = 6523 + self.match(PLpgSQLParser.AS) + self.state = 6524 + self.window_definition() + self.state = 6530 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,837,self._ctx) + + + + pass + elif token in [PLpgSQLParser.TABLE]: + self.enterOuterAlt(localctx, 2) + self.state = 6533 + self.match(PLpgSQLParser.TABLE) + self.state = 6535 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 6534 + self.match(PLpgSQLParser.ONLY) + + + self.state = 6537 + self.schema_qualified_name() + self.state = 6539 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,840,self._ctx) + if la_ == 1: + self.state = 6538 + self.match(PLpgSQLParser.MULTIPLY) + + + pass + elif token in [PLpgSQLParser.VALUES]: + self.enterOuterAlt(localctx, 3) + self.state = 6541 + self.values_stmt() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Select_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_sublist(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Select_sublistContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Select_sublistContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_list" ): + listener.enterSelect_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_list" ): + listener.exitSelect_list(self) + + + + + def select_list(self): + + localctx = PLpgSQLParser.Select_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 638, self.RULE_select_list) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6544 + self.select_sublist() + self.state = 6549 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,842,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 6545 + self.match(PLpgSQLParser.COMMA) + self.state = 6546 + self.select_sublist() + self.state = 6551 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,842,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Select_sublistContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def col_label(self): + return self.getTypedRuleContext(PLpgSQLParser.Col_labelContext,0) + + + def id_token(self): + return self.getTypedRuleContext(PLpgSQLParser.Id_tokenContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_select_sublist + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelect_sublist" ): + listener.enterSelect_sublist(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelect_sublist" ): + listener.exitSelect_sublist(self) + + + + + def select_sublist(self): + + localctx = PLpgSQLParser.Select_sublistContext(self, self._ctx, self.state) + self.enterRule(localctx, 640, self.RULE_select_sublist) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6552 + self.vex(0) + self.state = 6556 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,843,self._ctx) + if la_ == 1: + self.state = 6553 + self.match(PLpgSQLParser.AS) + self.state = 6554 + self.col_label() + + elif la_ == 2: + self.state = 6555 + self.id_token() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Into_tableContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(PLpgSQLParser.INTO, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def TEMPORARY(self): + return self.getToken(PLpgSQLParser.TEMPORARY, 0) + + def TEMP(self): + return self.getToken(PLpgSQLParser.TEMP, 0) + + def UNLOGGED(self): + return self.getToken(PLpgSQLParser.UNLOGGED, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_into_table + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInto_table" ): + listener.enterInto_table(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInto_table" ): + listener.exitInto_table(self) + + + + + def into_table(self): + + localctx = PLpgSQLParser.Into_tableContext(self, self._ctx, self.state) + self.enterRule(localctx, 642, self.RULE_into_table) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6558 + self.match(PLpgSQLParser.INTO) + self.state = 6560 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,844,self._ctx) + if la_ == 1: + self.state = 6559 + _la = self._input.LA(1) + if not(((((_la - 253)) & ~0x3f) == 0 and ((1 << (_la - 253)) & ((1 << (PLpgSQLParser.TEMP - 253)) | (1 << (PLpgSQLParser.TEMPORARY - 253)) | (1 << (PLpgSQLParser.UNLOGGED - 253)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 6563 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLE: + self.state = 6562 + self.match(PLpgSQLParser.TABLE) + + + self.state = 6565 + self.schema_qualified_name() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class From_itemContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def from_item(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.From_itemContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.From_itemContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def alias_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Alias_clauseContext,0) + + + def from_primary(self): + return self.getTypedRuleContext(PLpgSQLParser.From_primaryContext,0) + + + def CROSS(self): + return self.getToken(PLpgSQLParser.CROSS, 0) + + def JOIN(self): + return self.getToken(PLpgSQLParser.JOIN, 0) + + def NATURAL(self): + return self.getToken(PLpgSQLParser.NATURAL, 0) + + def INNER(self): + return self.getToken(PLpgSQLParser.INNER, 0) + + def LEFT(self): + return self.getToken(PLpgSQLParser.LEFT, 0) + + def RIGHT(self): + return self.getToken(PLpgSQLParser.RIGHT, 0) + + def FULL(self): + return self.getToken(PLpgSQLParser.FULL, 0) + + def OUTER(self): + return self.getToken(PLpgSQLParser.OUTER, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def names_in_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Names_in_parensContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_from_item + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFrom_item" ): + listener.enterFrom_item(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFrom_item" ): + listener.exitFrom_item(self) + + + + def from_item(self, _p:int=0): + _parentctx = self._ctx + _parentState = self.state + localctx = PLpgSQLParser.From_itemContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 644 + self.enterRecursionRule(localctx, 644, self.RULE_from_item, _p) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6575 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,847,self._ctx) + if la_ == 1: + self.state = 6568 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6569 + self.from_item(0) + self.state = 6570 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 6572 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,846,self._ctx) + if la_ == 1: + self.state = 6571 + self.alias_clause() + + + pass + + elif la_ == 2: + self.state = 6574 + self.from_primary() + pass + + + self._ctx.stop = self._input.LT(-1) + self.state = 6620 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,855,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + self.state = 6618 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,854,self._ctx) + if la_ == 1: + localctx = PLpgSQLParser.From_itemContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_from_item) + self.state = 6577 + if not self.precpred(self._ctx, 5): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 5)") + self.state = 6578 + self.match(PLpgSQLParser.CROSS) + self.state = 6579 + self.match(PLpgSQLParser.JOIN) + self.state = 6580 + self.from_item(6) + pass + + elif la_ == 2: + localctx = PLpgSQLParser.From_itemContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_from_item) + self.state = 6581 + if not self.precpred(self._ctx, 2): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + self.state = 6582 + self.match(PLpgSQLParser.NATURAL) + self.state = 6588 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.INNER]: + self.state = 6583 + self.match(PLpgSQLParser.INNER) + pass + elif token in [PLpgSQLParser.FULL, PLpgSQLParser.LEFT, PLpgSQLParser.RIGHT]: + self.state = 6584 + _la = self._input.LA(1) + if not(((((_la - 350)) & ~0x3f) == 0 and ((1 << (_la - 350)) & ((1 << (PLpgSQLParser.FULL - 350)) | (1 << (PLpgSQLParser.LEFT - 350)) | (1 << (PLpgSQLParser.RIGHT - 350)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6586 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OUTER: + self.state = 6585 + self.match(PLpgSQLParser.OUTER) + + + pass + elif token in [PLpgSQLParser.JOIN]: + pass + else: + pass + self.state = 6590 + self.match(PLpgSQLParser.JOIN) + self.state = 6591 + self.from_item(3) + pass + + elif la_ == 3: + localctx = PLpgSQLParser.From_itemContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_from_item) + self.state = 6592 + if not self.precpred(self._ctx, 4): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 4)") + self.state = 6598 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.INNER]: + self.state = 6593 + self.match(PLpgSQLParser.INNER) + pass + elif token in [PLpgSQLParser.FULL, PLpgSQLParser.LEFT, PLpgSQLParser.RIGHT]: + self.state = 6594 + _la = self._input.LA(1) + if not(((((_la - 350)) & ~0x3f) == 0 and ((1 << (_la - 350)) & ((1 << (PLpgSQLParser.FULL - 350)) | (1 << (PLpgSQLParser.LEFT - 350)) | (1 << (PLpgSQLParser.RIGHT - 350)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6596 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OUTER: + self.state = 6595 + self.match(PLpgSQLParser.OUTER) + + + pass + elif token in [PLpgSQLParser.JOIN]: + pass + else: + pass + self.state = 6600 + self.match(PLpgSQLParser.JOIN) + self.state = 6601 + self.from_item(0) + self.state = 6602 + self.match(PLpgSQLParser.ON) + self.state = 6603 + self.vex(0) + pass + + elif la_ == 4: + localctx = PLpgSQLParser.From_itemContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_from_item) + self.state = 6605 + if not self.precpred(self._ctx, 3): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + self.state = 6611 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.INNER]: + self.state = 6606 + self.match(PLpgSQLParser.INNER) + pass + elif token in [PLpgSQLParser.FULL, PLpgSQLParser.LEFT, PLpgSQLParser.RIGHT]: + self.state = 6607 + _la = self._input.LA(1) + if not(((((_la - 350)) & ~0x3f) == 0 and ((1 << (_la - 350)) & ((1 << (PLpgSQLParser.FULL - 350)) | (1 << (PLpgSQLParser.LEFT - 350)) | (1 << (PLpgSQLParser.RIGHT - 350)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6609 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OUTER: + self.state = 6608 + self.match(PLpgSQLParser.OUTER) + + + pass + elif token in [PLpgSQLParser.JOIN]: + pass + else: + pass + self.state = 6613 + self.match(PLpgSQLParser.JOIN) + self.state = 6614 + self.from_item(0) + self.state = 6615 + self.match(PLpgSQLParser.USING) + self.state = 6616 + self.names_in_parens() + pass + + + self.state = 6622 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,855,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + + class From_primaryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.method = None # IdentifierContext + self.alias = None # IdentifierContext + self._identifier = None # IdentifierContext + self.column_alias = list() # of IdentifierContexts + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def alias_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Alias_clauseContext,0) + + + def TABLESAMPLE(self): + return self.getToken(PLpgSQLParser.TABLESAMPLE, 0) + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def REPEATABLE(self): + return self.getToken(PLpgSQLParser.REPEATABLE, 0) + + def table_subquery(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_subqueryContext,0) + + + def LATERAL(self): + return self.getToken(PLpgSQLParser.LATERAL, 0) + + def function_call(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_callContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,i) + + + def WITH(self): + return self.getToken(PLpgSQLParser.WITH, 0) + + def ORDINALITY(self): + return self.getToken(PLpgSQLParser.ORDINALITY, 0) + + def AS(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.AS) + else: + return self.getToken(PLpgSQLParser.AS, i) + + def from_function_column_def(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.From_function_column_defContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.From_function_column_defContext,i) + + + def ROWS(self): + return self.getToken(PLpgSQLParser.ROWS, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_from_primary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFrom_primary" ): + listener.enterFrom_primary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFrom_primary" ): + listener.exitFrom_primary(self) + + + + + def from_primary(self): + + localctx = PLpgSQLParser.From_primaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 646, self.RULE_from_primary) + self._la = 0 # Token type + try: + self.state = 6733 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,878,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6624 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 6623 + self.match(PLpgSQLParser.ONLY) + + + self.state = 6626 + self.schema_qualified_name() + self.state = 6628 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,857,self._ctx) + if la_ == 1: + self.state = 6627 + self.match(PLpgSQLParser.MULTIPLY) + + + self.state = 6631 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,858,self._ctx) + if la_ == 1: + self.state = 6630 + self.alias_clause() + + + self.state = 6649 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,861,self._ctx) + if la_ == 1: + self.state = 6633 + self.match(PLpgSQLParser.TABLESAMPLE) + self.state = 6634 + localctx.method = self.identifier() + self.state = 6635 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6636 + self.vex(0) + self.state = 6641 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6637 + self.match(PLpgSQLParser.COMMA) + self.state = 6638 + self.vex(0) + self.state = 6643 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6644 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 6647 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,860,self._ctx) + if la_ == 1: + self.state = 6645 + self.match(PLpgSQLParser.REPEATABLE) + self.state = 6646 + self.vex(0) + + + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6652 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LATERAL: + self.state = 6651 + self.match(PLpgSQLParser.LATERAL) + + + self.state = 6654 + self.table_subquery() + self.state = 6655 + self.alias_clause() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6658 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LATERAL: + self.state = 6657 + self.match(PLpgSQLParser.LATERAL) + + + self.state = 6660 + self.function_call() + self.state = 6663 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,864,self._ctx) + if la_ == 1: + self.state = 6661 + self.match(PLpgSQLParser.WITH) + self.state = 6662 + self.match(PLpgSQLParser.ORDINALITY) + + + self.state = 6685 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,868,self._ctx) + if la_ == 1: + self.state = 6665 + self.match(PLpgSQLParser.AS) + self.state = 6666 + self.from_function_column_def() + + elif la_ == 2: + self.state = 6668 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6667 + self.match(PLpgSQLParser.AS) + + + self.state = 6670 + localctx.alias = self.identifier() + self.state = 6683 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,867,self._ctx) + if la_ == 1: + self.state = 6671 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6672 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6677 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6673 + self.match(PLpgSQLParser.COMMA) + self.state = 6674 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6679 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6680 + self.match(PLpgSQLParser.RIGHT_PAREN) + + elif la_ == 2: + self.state = 6682 + self.from_function_column_def() + + + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 6688 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LATERAL: + self.state = 6687 + self.match(PLpgSQLParser.LATERAL) + + + self.state = 6690 + self.match(PLpgSQLParser.ROWS) + self.state = 6691 + self.match(PLpgSQLParser.FROM) + self.state = 6692 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6693 + self.function_call() + self.state = 6696 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6694 + self.match(PLpgSQLParser.AS) + self.state = 6695 + self.from_function_column_def() + + + self.state = 6706 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6698 + self.match(PLpgSQLParser.COMMA) + self.state = 6699 + self.function_call() + self.state = 6702 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6700 + self.match(PLpgSQLParser.AS) + self.state = 6701 + self.from_function_column_def() + + + self.state = 6708 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6709 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 6712 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,873,self._ctx) + if la_ == 1: + self.state = 6710 + self.match(PLpgSQLParser.WITH) + self.state = 6711 + self.match(PLpgSQLParser.ORDINALITY) + + + self.state = 6731 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,877,self._ctx) + if la_ == 1: + self.state = 6715 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6714 + self.match(PLpgSQLParser.AS) + + + self.state = 6717 + localctx.alias = self.identifier() + self.state = 6729 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,876,self._ctx) + if la_ == 1: + self.state = 6718 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6719 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6724 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6720 + self.match(PLpgSQLParser.COMMA) + self.state = 6721 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6726 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6727 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Alias_clauseContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.alias = None # IdentifierContext + self._identifier = None # IdentifierContext + self.column_alias = list() # of IdentifierContexts + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_alias_clause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlias_clause" ): + listener.enterAlias_clause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlias_clause" ): + listener.exitAlias_clause(self) + + + + + def alias_clause(self): + + localctx = PLpgSQLParser.Alias_clauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 648, self.RULE_alias_clause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6736 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6735 + self.match(PLpgSQLParser.AS) + + + self.state = 6738 + localctx.alias = self.identifier() + self.state = 6750 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,881,self._ctx) + if la_ == 1: + self.state = 6739 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6740 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6745 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6741 + self.match(PLpgSQLParser.COMMA) + self.state = 6742 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6747 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6748 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class From_function_column_defContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self._identifier = None # IdentifierContext + self.column_alias = list() # of IdentifierContexts + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_from_function_column_def + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFrom_function_column_def" ): + listener.enterFrom_function_column_def(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFrom_function_column_def" ): + listener.exitFrom_function_column_def(self) + + + + + def from_function_column_def(self): + + localctx = PLpgSQLParser.From_function_column_defContext(self, self._ctx, self.state) + self.enterRule(localctx, 650, self.RULE_from_function_column_def) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6752 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6753 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6754 + self.data_type() + self.state = 6761 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6755 + self.match(PLpgSQLParser.COMMA) + self.state = 6756 + localctx._identifier = self.identifier() + localctx.column_alias.append(localctx._identifier) + self.state = 6757 + self.data_type() + self.state = 6763 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6764 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Groupby_clauseContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GROUP(self): + return self.getToken(PLpgSQLParser.GROUP, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def grouping_element_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Grouping_element_listContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_groupby_clause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGroupby_clause" ): + listener.enterGroupby_clause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGroupby_clause" ): + listener.exitGroupby_clause(self) + + + + + def groupby_clause(self): + + localctx = PLpgSQLParser.Groupby_clauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 652, self.RULE_groupby_clause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6766 + self.match(PLpgSQLParser.GROUP) + self.state = 6767 + self.match(PLpgSQLParser.BY) + self.state = 6768 + self.grouping_element_list() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Grouping_element_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def grouping_element(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Grouping_elementContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Grouping_elementContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_grouping_element_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGrouping_element_list" ): + listener.enterGrouping_element_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGrouping_element_list" ): + listener.exitGrouping_element_list(self) + + + + + def grouping_element_list(self): + + localctx = PLpgSQLParser.Grouping_element_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 654, self.RULE_grouping_element_list) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6770 + self.grouping_element() + self.state = 6775 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,883,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 6771 + self.match(PLpgSQLParser.COMMA) + self.state = 6772 + self.grouping_element() + self.state = 6777 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,883,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Grouping_elementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def grouping_element_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Grouping_element_listContext,0) + + + def ROLLUP(self): + return self.getToken(PLpgSQLParser.ROLLUP, 0) + + def CUBE(self): + return self.getToken(PLpgSQLParser.CUBE, 0) + + def GROUPING(self): + return self.getToken(PLpgSQLParser.GROUPING, 0) + + def SETS(self): + return self.getToken(PLpgSQLParser.SETS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_grouping_element + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGrouping_element" ): + listener.enterGrouping_element(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGrouping_element" ): + listener.exitGrouping_element(self) + + + + + def grouping_element(self): + + localctx = PLpgSQLParser.Grouping_elementContext(self, self._ctx, self.state) + self.enterRule(localctx, 656, self.RULE_grouping_element) + try: + self.state = 6791 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,885,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6778 + self.vex(0) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6779 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6780 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6785 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ROLLUP]: + self.state = 6781 + self.match(PLpgSQLParser.ROLLUP) + pass + elif token in [PLpgSQLParser.CUBE]: + self.state = 6782 + self.match(PLpgSQLParser.CUBE) + pass + elif token in [PLpgSQLParser.GROUPING]: + self.state = 6783 + self.match(PLpgSQLParser.GROUPING) + self.state = 6784 + self.match(PLpgSQLParser.SETS) + pass + else: + raise NoViableAltException(self) + + self.state = 6787 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6788 + self.grouping_element_list() + self.state = 6789 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Values_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VALUES(self): + return self.getToken(PLpgSQLParser.VALUES, 0) + + def values_values(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Values_valuesContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Values_valuesContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_values_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValues_stmt" ): + listener.enterValues_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValues_stmt" ): + listener.exitValues_stmt(self) + + + + + def values_stmt(self): + + localctx = PLpgSQLParser.Values_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 658, self.RULE_values_stmt) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6793 + self.match(PLpgSQLParser.VALUES) + self.state = 6794 + self.values_values() + self.state = 6799 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,886,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 6795 + self.match(PLpgSQLParser.COMMA) + self.state = 6796 + self.values_values() + self.state = 6801 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,886,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Values_valuesContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def DEFAULT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DEFAULT) + else: + return self.getToken(PLpgSQLParser.DEFAULT, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_values_values + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValues_values" ): + listener.enterValues_values(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValues_values" ): + listener.exitValues_values(self) + + + + + def values_values(self): + + localctx = PLpgSQLParser.Values_valuesContext(self, self._ctx, self.state) + self.enterRule(localctx, 660, self.RULE_values_values) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6802 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6805 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 6803 + self.vex(0) + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 6804 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + self.state = 6814 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6807 + self.match(PLpgSQLParser.COMMA) + self.state = 6810 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 6808 + self.vex(0) + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 6809 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + self.state = 6816 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6817 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Orderby_clauseContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ORDER(self): + return self.getToken(PLpgSQLParser.ORDER, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def sort_specifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Sort_specifier_listContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_orderby_clause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOrderby_clause" ): + listener.enterOrderby_clause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOrderby_clause" ): + listener.exitOrderby_clause(self) + + + + + def orderby_clause(self): + + localctx = PLpgSQLParser.Orderby_clauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 662, self.RULE_orderby_clause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6819 + self.match(PLpgSQLParser.ORDER) + self.state = 6820 + self.match(PLpgSQLParser.BY) + self.state = 6821 + self.sort_specifier_list() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Sort_specifier_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def sort_specifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Sort_specifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Sort_specifierContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_sort_specifier_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSort_specifier_list" ): + listener.enterSort_specifier_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSort_specifier_list" ): + listener.exitSort_specifier_list(self) + + + + + def sort_specifier_list(self): + + localctx = PLpgSQLParser.Sort_specifier_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 664, self.RULE_sort_specifier_list) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6823 + self.sort_specifier() + self.state = 6828 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6824 + self.match(PLpgSQLParser.COMMA) + self.state = 6825 + self.sort_specifier() + self.state = 6830 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Sort_specifierContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.key = None # VexContext + self.opclass = None # Schema_qualified_nameContext + self.order = None # Order_specificationContext + self.null_order = None # Null_orderingContext + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def order_specification(self): + return self.getTypedRuleContext(PLpgSQLParser.Order_specificationContext,0) + + + def null_ordering(self): + return self.getTypedRuleContext(PLpgSQLParser.Null_orderingContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_sort_specifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSort_specifier" ): + listener.enterSort_specifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSort_specifier" ): + listener.exitSort_specifier(self) + + + + + def sort_specifier(self): + + localctx = PLpgSQLParser.Sort_specifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 666, self.RULE_sort_specifier) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6831 + localctx.key = self.vex(0) + self.state = 6833 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,891,self._ctx) + if la_ == 1: + self.state = 6832 + localctx.opclass = self.schema_qualified_name() + + + self.state = 6836 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ASC or _la==PLpgSQLParser.DESC or _la==PLpgSQLParser.USING: + self.state = 6835 + localctx.order = self.order_specification() + + + self.state = 6839 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NULLS: + self.state = 6838 + localctx.null_order = self.null_ordering() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Order_specificationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASC(self): + return self.getToken(PLpgSQLParser.ASC, 0) + + def DESC(self): + return self.getToken(PLpgSQLParser.DESC, 0) + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def all_op_ref(self): + return self.getTypedRuleContext(PLpgSQLParser.All_op_refContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_order_specification + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOrder_specification" ): + listener.enterOrder_specification(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOrder_specification" ): + listener.exitOrder_specification(self) + + + + + def order_specification(self): + + localctx = PLpgSQLParser.Order_specificationContext(self, self._ctx, self.state) + self.enterRule(localctx, 668, self.RULE_order_specification) + try: + self.state = 6845 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ASC]: + self.enterOuterAlt(localctx, 1) + self.state = 6841 + self.match(PLpgSQLParser.ASC) + pass + elif token in [PLpgSQLParser.DESC]: + self.enterOuterAlt(localctx, 2) + self.state = 6842 + self.match(PLpgSQLParser.DESC) + pass + elif token in [PLpgSQLParser.USING]: + self.enterOuterAlt(localctx, 3) + self.state = 6843 + self.match(PLpgSQLParser.USING) + self.state = 6844 + self.all_op_ref() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Null_orderingContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NULLS(self): + return self.getToken(PLpgSQLParser.NULLS, 0) + + def FIRST(self): + return self.getToken(PLpgSQLParser.FIRST, 0) + + def LAST(self): + return self.getToken(PLpgSQLParser.LAST, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_null_ordering + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNull_ordering" ): + listener.enterNull_ordering(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNull_ordering" ): + listener.exitNull_ordering(self) + + + + + def null_ordering(self): + + localctx = PLpgSQLParser.Null_orderingContext(self, self._ctx, self.state) + self.enterRule(localctx, 670, self.RULE_null_ordering) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6847 + self.match(PLpgSQLParser.NULLS) + self.state = 6848 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FIRST or _la==PLpgSQLParser.LAST): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Insert_stmt_for_psqlContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.insert_table_name = None # Schema_qualified_nameContext + self.alias = None # IdentifierContext + + def INSERT(self): + return self.getToken(PLpgSQLParser.INSERT, 0) + + def INTO(self): + return self.getToken(PLpgSQLParser.INTO, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def VALUES(self): + return self.getToken(PLpgSQLParser.VALUES, 0) + + def with_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.With_clauseContext,0) + + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def OVERRIDING(self): + return self.getToken(PLpgSQLParser.OVERRIDING, 0) + + def VALUE(self): + return self.getToken(PLpgSQLParser.VALUE, 0) + + def insert_columns(self): + return self.getTypedRuleContext(PLpgSQLParser.Insert_columnsContext,0) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def CONFLICT(self): + return self.getToken(PLpgSQLParser.CONFLICT, 0) + + def conflict_action(self): + return self.getTypedRuleContext(PLpgSQLParser.Conflict_actionContext,0) + + + def RETURNING(self): + return self.getToken(PLpgSQLParser.RETURNING, 0) + + def select_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_listContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def SYSTEM(self): + return self.getToken(PLpgSQLParser.SYSTEM, 0) + + def USER(self): + return self.getToken(PLpgSQLParser.USER, 0) + + def conflict_object(self): + return self.getTypedRuleContext(PLpgSQLParser.Conflict_objectContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_insert_stmt_for_psql + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInsert_stmt_for_psql" ): + listener.enterInsert_stmt_for_psql(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInsert_stmt_for_psql" ): + listener.exitInsert_stmt_for_psql(self) + + + + + def insert_stmt_for_psql(self): + + localctx = PLpgSQLParser.Insert_stmt_for_psqlContext(self, self._ctx, self.state) + self.enterRule(localctx, 672, self.RULE_insert_stmt_for_psql) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6851 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 6850 + self.with_clause() + + + self.state = 6853 + self.match(PLpgSQLParser.INSERT) + self.state = 6854 + self.match(PLpgSQLParser.INTO) + self.state = 6855 + localctx.insert_table_name = self.schema_qualified_name() + self.state = 6858 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6856 + self.match(PLpgSQLParser.AS) + self.state = 6857 + localctx.alias = self.identifier() + + + self.state = 6863 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.OVERRIDING: + self.state = 6860 + self.match(PLpgSQLParser.OVERRIDING) + self.state = 6861 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.SYSTEM or _la==PLpgSQLParser.USER): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6862 + self.match(PLpgSQLParser.VALUE) + + + self.state = 6866 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,898,self._ctx) + if la_ == 1: + self.state = 6865 + self.insert_columns() + + + self.state = 6871 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE, PLpgSQLParser.WITH, PLpgSQLParser.LEFT_PAREN]: + self.state = 6868 + self.select_stmt() + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 6869 + self.match(PLpgSQLParser.DEFAULT) + self.state = 6870 + self.match(PLpgSQLParser.VALUES) + pass + else: + raise NoViableAltException(self) + + self.state = 6879 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ON: + self.state = 6873 + self.match(PLpgSQLParser.ON) + self.state = 6874 + self.match(PLpgSQLParser.CONFLICT) + self.state = 6876 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ON or _la==PLpgSQLParser.LEFT_PAREN: + self.state = 6875 + self.conflict_object() + + + self.state = 6878 + self.conflict_action() + + + self.state = 6883 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.RETURNING: + self.state = 6881 + self.match(PLpgSQLParser.RETURNING) + self.state = 6882 + self.select_list() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Insert_columnsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def indirection_identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Indirection_identifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Indirection_identifierContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_insert_columns + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInsert_columns" ): + listener.enterInsert_columns(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInsert_columns" ): + listener.exitInsert_columns(self) + + + + + def insert_columns(self): + + localctx = PLpgSQLParser.Insert_columnsContext(self, self._ctx, self.state) + self.enterRule(localctx, 674, self.RULE_insert_columns) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6885 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 6886 + self.indirection_identifier() + self.state = 6891 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6887 + self.match(PLpgSQLParser.COMMA) + self.state = 6888 + self.indirection_identifier() + self.state = 6893 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6894 + self.match(PLpgSQLParser.RIGHT_PAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Indirection_identifierContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def indirection_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Indirection_listContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_indirection_identifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndirection_identifier" ): + listener.enterIndirection_identifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndirection_identifier" ): + listener.exitIndirection_identifier(self) + + + + + def indirection_identifier(self): + + localctx = PLpgSQLParser.Indirection_identifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 676, self.RULE_indirection_identifier) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6896 + self.identifier() + self.state = 6898 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DOT or _la==PLpgSQLParser.LEFT_BRACKET: + self.state = 6897 + self.indirection_list() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Conflict_objectContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def index_sort(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_sortContext,0) + + + def index_where(self): + return self.getTypedRuleContext(PLpgSQLParser.Index_whereContext,0) + + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_conflict_object + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConflict_object" ): + listener.enterConflict_object(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConflict_object" ): + listener.exitConflict_object(self) + + + + + def conflict_object(self): + + localctx = PLpgSQLParser.Conflict_objectContext(self, self._ctx, self.state) + self.enterRule(localctx, 678, self.RULE_conflict_object) + self._la = 0 # Token type + try: + self.state = 6907 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 1) + self.state = 6900 + self.index_sort() + self.state = 6902 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 6901 + self.index_where() + + + pass + elif token in [PLpgSQLParser.ON]: + self.enterOuterAlt(localctx, 2) + self.state = 6904 + self.match(PLpgSQLParser.ON) + self.state = 6905 + self.match(PLpgSQLParser.CONSTRAINT) + self.state = 6906 + self.identifier() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Conflict_actionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DO(self): + return self.getToken(PLpgSQLParser.DO, 0) + + def NOTHING(self): + return self.getToken(PLpgSQLParser.NOTHING, 0) + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def update_set(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Update_setContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Update_setContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_conflict_action + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConflict_action" ): + listener.enterConflict_action(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConflict_action" ): + listener.exitConflict_action(self) + + + + + def conflict_action(self): + + localctx = PLpgSQLParser.Conflict_actionContext(self, self._ctx, self.state) + self.enterRule(localctx, 680, self.RULE_conflict_action) + self._la = 0 # Token type + try: + self.state = 6926 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,909,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6909 + self.match(PLpgSQLParser.DO) + self.state = 6910 + self.match(PLpgSQLParser.NOTHING) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6911 + self.match(PLpgSQLParser.DO) + self.state = 6912 + self.match(PLpgSQLParser.UPDATE) + self.state = 6913 + self.match(PLpgSQLParser.SET) + self.state = 6914 + self.update_set() + self.state = 6919 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6915 + self.match(PLpgSQLParser.COMMA) + self.state = 6916 + self.update_set() + self.state = 6921 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6924 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 6922 + self.match(PLpgSQLParser.WHERE) + self.state = 6923 + self.vex(0) + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Delete_stmt_for_psqlContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.delete_table_name = None # Schema_qualified_nameContext + self.alias = None # IdentifierContext + self.cursor = None # IdentifierContext + + def DELETE(self): + return self.getToken(PLpgSQLParser.DELETE, 0) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def with_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.With_clauseContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def from_item(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.From_itemContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.From_itemContext,i) + + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def RETURNING(self): + return self.getToken(PLpgSQLParser.RETURNING, 0) + + def select_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_listContext,0) + + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_delete_stmt_for_psql + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDelete_stmt_for_psql" ): + listener.enterDelete_stmt_for_psql(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDelete_stmt_for_psql" ): + listener.exitDelete_stmt_for_psql(self) + + + + + def delete_stmt_for_psql(self): + + localctx = PLpgSQLParser.Delete_stmt_for_psqlContext(self, self._ctx, self.state) + self.enterRule(localctx, 682, self.RULE_delete_stmt_for_psql) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6929 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 6928 + self.with_clause() + + + self.state = 6931 + self.match(PLpgSQLParser.DELETE) + self.state = 6932 + self.match(PLpgSQLParser.FROM) + self.state = 6934 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 6933 + self.match(PLpgSQLParser.ONLY) + + + self.state = 6936 + localctx.delete_table_name = self.schema_qualified_name() + self.state = 6938 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MULTIPLY: + self.state = 6937 + self.match(PLpgSQLParser.MULTIPLY) + + + self.state = 6944 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,914,self._ctx) + if la_ == 1: + self.state = 6941 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6940 + self.match(PLpgSQLParser.AS) + + + self.state = 6943 + localctx.alias = self.identifier() + + + self.state = 6955 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 6946 + self.match(PLpgSQLParser.USING) + self.state = 6947 + self.from_item(0) + self.state = 6952 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6948 + self.match(PLpgSQLParser.COMMA) + self.state = 6949 + self.from_item(0) + self.state = 6954 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 6964 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 6957 + self.match(PLpgSQLParser.WHERE) + self.state = 6962 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,917,self._ctx) + if la_ == 1: + self.state = 6958 + self.vex(0) + pass + + elif la_ == 2: + self.state = 6959 + self.match(PLpgSQLParser.CURRENT) + self.state = 6960 + self.match(PLpgSQLParser.OF) + self.state = 6961 + localctx.cursor = self.identifier() + pass + + + + + self.state = 6968 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.RETURNING: + self.state = 6966 + self.match(PLpgSQLParser.RETURNING) + self.state = 6967 + self.select_list() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Update_stmt_for_psqlContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.update_table_name = None # Schema_qualified_nameContext + self.alias = None # IdentifierContext + self.cursor = None # IdentifierContext + + def UPDATE(self): + return self.getToken(PLpgSQLParser.UPDATE, 0) + + def SET(self): + return self.getToken(PLpgSQLParser.SET, 0) + + def update_set(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Update_setContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Update_setContext,i) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def with_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.With_clauseContext,0) + + + def ONLY(self): + return self.getToken(PLpgSQLParser.ONLY, 0) + + def MULTIPLY(self): + return self.getToken(PLpgSQLParser.MULTIPLY, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def from_item(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.From_itemContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.From_itemContext,i) + + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def RETURNING(self): + return self.getToken(PLpgSQLParser.RETURNING, 0) + + def select_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_listContext,0) + + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def OF(self): + return self.getToken(PLpgSQLParser.OF, 0) + + def AS(self): + return self.getToken(PLpgSQLParser.AS, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_update_stmt_for_psql + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUpdate_stmt_for_psql" ): + listener.enterUpdate_stmt_for_psql(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUpdate_stmt_for_psql" ): + listener.exitUpdate_stmt_for_psql(self) + + + + + def update_stmt_for_psql(self): + + localctx = PLpgSQLParser.Update_stmt_for_psqlContext(self, self._ctx, self.state) + self.enterRule(localctx, 684, self.RULE_update_stmt_for_psql) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6971 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WITH: + self.state = 6970 + self.with_clause() + + + self.state = 6973 + self.match(PLpgSQLParser.UPDATE) + self.state = 6975 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ONLY: + self.state = 6974 + self.match(PLpgSQLParser.ONLY) + + + self.state = 6977 + localctx.update_table_name = self.schema_qualified_name() + self.state = 6979 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.MULTIPLY: + self.state = 6978 + self.match(PLpgSQLParser.MULTIPLY) + + + self.state = 6985 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,924,self._ctx) + if la_ == 1: + self.state = 6982 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AS: + self.state = 6981 + self.match(PLpgSQLParser.AS) + + + self.state = 6984 + localctx.alias = self.identifier() + + + self.state = 6987 + self.match(PLpgSQLParser.SET) + self.state = 6988 + self.update_set() + self.state = 6993 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6989 + self.match(PLpgSQLParser.COMMA) + self.state = 6990 + self.update_set() + self.state = 6995 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7005 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM: + self.state = 6996 + self.match(PLpgSQLParser.FROM) + self.state = 6997 + self.from_item(0) + self.state = 7002 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 6998 + self.match(PLpgSQLParser.COMMA) + self.state = 6999 + self.from_item(0) + self.state = 7004 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 7014 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 7007 + self.match(PLpgSQLParser.WHERE) + self.state = 7012 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,928,self._ctx) + if la_ == 1: + self.state = 7008 + self.vex(0) + pass + + elif la_ == 2: + self.state = 7009 + self.match(PLpgSQLParser.CURRENT) + self.state = 7010 + self.match(PLpgSQLParser.OF) + self.state = 7011 + localctx.cursor = self.identifier() + pass + + + + + self.state = 7018 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.RETURNING: + self.state = 7016 + self.match(PLpgSQLParser.RETURNING) + self.state = 7017 + self.select_list() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Update_setContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self._indirection_identifier = None # Indirection_identifierContext + self.column = list() # of Indirection_identifierContexts + self._vex = None # VexContext + self.value = list() # of VexContexts + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def indirection_identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Indirection_identifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Indirection_identifierContext,i) + + + def DEFAULT(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DEFAULT) + else: + return self.getToken(PLpgSQLParser.DEFAULT, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def LEFT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_PAREN) + else: + return self.getToken(PLpgSQLParser.LEFT_PAREN, i) + + def RIGHT_PAREN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_PAREN) + else: + return self.getToken(PLpgSQLParser.RIGHT_PAREN, i) + + def table_subquery(self): + return self.getTypedRuleContext(PLpgSQLParser.Table_subqueryContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def ROW(self): + return self.getToken(PLpgSQLParser.ROW, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_update_set + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUpdate_set" ): + listener.enterUpdate_set(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUpdate_set" ): + listener.exitUpdate_set(self) + + + + + def update_set(self): + + localctx = PLpgSQLParser.Update_setContext(self, self._ctx, self.state) + self.enterRule(localctx, 686, self.RULE_update_set) + self._la = 0 # Token type + try: + self.state = 7059 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.enterOuterAlt(localctx, 1) + self.state = 7020 + localctx._indirection_identifier = self.indirection_identifier() + localctx.column.append(localctx._indirection_identifier) + self.state = 7021 + self.match(PLpgSQLParser.EQUAL) + self.state = 7024 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 7022 + localctx._vex = self.vex(0) + localctx.value.append(localctx._vex) + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 7023 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + pass + elif token in [PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 2) + self.state = 7026 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 7027 + localctx._indirection_identifier = self.indirection_identifier() + localctx.column.append(localctx._indirection_identifier) + self.state = 7032 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7028 + self.match(PLpgSQLParser.COMMA) + self.state = 7029 + localctx._indirection_identifier = self.indirection_identifier() + localctx.column.append(localctx._indirection_identifier) + self.state = 7034 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7035 + self.match(PLpgSQLParser.RIGHT_PAREN) + self.state = 7036 + self.match(PLpgSQLParser.EQUAL) + self.state = 7038 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ROW: + self.state = 7037 + self.match(PLpgSQLParser.ROW) + + + self.state = 7057 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,937,self._ctx) + if la_ == 1: + self.state = 7040 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 7043 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 7041 + localctx._vex = self.vex(0) + localctx.value.append(localctx._vex) + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 7042 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + self.state = 7052 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7045 + self.match(PLpgSQLParser.COMMA) + self.state = 7048 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.AUTHORIZATION, PLpgSQLParser.BINARY, PLpgSQLParser.COLLATION, PLpgSQLParser.CONCURRENTLY, PLpgSQLParser.CROSS, PLpgSQLParser.CURRENT_SCHEMA, PLpgSQLParser.FREEZE, PLpgSQLParser.FULL, PLpgSQLParser.ILIKE, PLpgSQLParser.INNER, PLpgSQLParser.IS, PLpgSQLParser.ISNULL, PLpgSQLParser.JOIN, PLpgSQLParser.LEFT, PLpgSQLParser.LIKE, PLpgSQLParser.NATURAL, PLpgSQLParser.NOTNULL, PLpgSQLParser.OUTER, PLpgSQLParser.OVERLAPS, PLpgSQLParser.RIGHT, PLpgSQLParser.SIMILAR, PLpgSQLParser.TABLESAMPLE, PLpgSQLParser.VERBOSE, PLpgSQLParser.ALL, PLpgSQLParser.ANY, PLpgSQLParser.ARRAY, PLpgSQLParser.CASE, PLpgSQLParser.CAST, PLpgSQLParser.CURRENT_CATALOG, PLpgSQLParser.CURRENT_DATE, PLpgSQLParser.CURRENT_TIME, PLpgSQLParser.CURRENT_TIMESTAMP, PLpgSQLParser.CURRENT_USER, PLpgSQLParser.FALSE, PLpgSQLParser.LOCALTIME, PLpgSQLParser.LOCALTIMESTAMP, PLpgSQLParser.NOT, PLpgSQLParser.NULL, PLpgSQLParser.ON, PLpgSQLParser.SESSION_USER, PLpgSQLParser.SOME, PLpgSQLParser.TRUE, PLpgSQLParser.USER, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.LEFT_PAREN, PLpgSQLParser.PLUS, PLpgSQLParser.MINUS, PLpgSQLParser.MULTIPLY, PLpgSQLParser.LESS_LESS, PLpgSQLParser.GREATER_GREATER, PLpgSQLParser.HASH_SIGN, PLpgSQLParser.OP_CHARS, PLpgSQLParser.NUMBER_LITERAL, PLpgSQLParser.REAL_NUMBER, PLpgSQLParser.DOLLAR_NUMBER, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier, PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 7046 + localctx._vex = self.vex(0) + localctx.value.append(localctx._vex) + pass + elif token in [PLpgSQLParser.DEFAULT]: + self.state = 7047 + self.match(PLpgSQLParser.DEFAULT) + pass + else: + raise NoViableAltException(self) + + self.state = 7054 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7055 + self.match(PLpgSQLParser.RIGHT_PAREN) + pass + + elif la_ == 2: + self.state = 7056 + self.table_subquery() + pass + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Notify_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.channel = None # IdentifierContext + self.payload = None # Character_stringContext + + def NOTIFY(self): + return self.getToken(PLpgSQLParser.NOTIFY, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def COMMA(self): + return self.getToken(PLpgSQLParser.COMMA, 0) + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_notify_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNotify_stmt" ): + listener.enterNotify_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNotify_stmt" ): + listener.exitNotify_stmt(self) + + + + + def notify_stmt(self): + + localctx = PLpgSQLParser.Notify_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 688, self.RULE_notify_stmt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7061 + self.match(PLpgSQLParser.NOTIFY) + self.state = 7062 + localctx.channel = self.identifier() + self.state = 7065 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 7063 + self.match(PLpgSQLParser.COMMA) + self.state = 7064 + localctx.payload = self.character_string() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Truncate_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRUNCATE(self): + return self.getToken(PLpgSQLParser.TRUNCATE, 0) + + def only_table_multiply(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Only_table_multiplyContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Only_table_multiplyContext,i) + + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def IDENTITY(self): + return self.getToken(PLpgSQLParser.IDENTITY, 0) + + def cascade_restrict(self): + return self.getTypedRuleContext(PLpgSQLParser.Cascade_restrictContext,0) + + + def RESTART(self): + return self.getToken(PLpgSQLParser.RESTART, 0) + + def CONTINUE(self): + return self.getToken(PLpgSQLParser.CONTINUE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_truncate_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTruncate_stmt" ): + listener.enterTruncate_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTruncate_stmt" ): + listener.exitTruncate_stmt(self) + + + + + def truncate_stmt(self): + + localctx = PLpgSQLParser.Truncate_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 690, self.RULE_truncate_stmt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7067 + self.match(PLpgSQLParser.TRUNCATE) + self.state = 7069 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.TABLE: + self.state = 7068 + self.match(PLpgSQLParser.TABLE) + + + self.state = 7071 + self.only_table_multiply() + self.state = 7076 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7072 + self.match(PLpgSQLParser.COMMA) + self.state = 7073 + self.only_table_multiply() + self.state = 7078 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7081 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CONTINUE or _la==PLpgSQLParser.RESTART: + self.state = 7079 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONTINUE or _la==PLpgSQLParser.RESTART): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7080 + self.match(PLpgSQLParser.IDENTITY) + + + self.state = 7084 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CASCADE or _la==PLpgSQLParser.RESTRICT: + self.state = 7083 + self.cascade_restrict() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Identifier_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_identifier_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentifier_list" ): + listener.enterIdentifier_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentifier_list" ): + listener.exitIdentifier_list(self) + + + + + def identifier_list(self): + + localctx = PLpgSQLParser.Identifier_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 692, self.RULE_identifier_list) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7086 + self.identifier() + self.state = 7091 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,944,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 7087 + self.match(PLpgSQLParser.COMMA) + self.state = 7088 + self.identifier() + self.state = 7093 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,944,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Anonymous_blockContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DO(self): + return self.getToken(PLpgSQLParser.DO, 0) + + def character_string(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Character_stringContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,i) + + + def LANGUAGE(self): + return self.getToken(PLpgSQLParser.LANGUAGE, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_anonymous_block + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAnonymous_block" ): + listener.enterAnonymous_block(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAnonymous_block" ): + listener.exitAnonymous_block(self) + + + + + def anonymous_block(self): + + localctx = PLpgSQLParser.Anonymous_blockContext(self, self._ctx, self.state) + self.enterRule(localctx, 694, self.RULE_anonymous_block) + self._la = 0 # Token type + try: + self.state = 7110 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,948,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7094 + self.match(PLpgSQLParser.DO) + self.state = 7100 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LANGUAGE: + self.state = 7095 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 7098 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 7096 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 7097 + self.character_string() + pass + else: + raise NoViableAltException(self) + + + + self.state = 7102 + self.character_string() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7103 + self.match(PLpgSQLParser.DO) + self.state = 7104 + self.character_string() + self.state = 7105 + self.match(PLpgSQLParser.LANGUAGE) + self.state = 7108 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 7106 + self.identifier() + pass + elif token in [PLpgSQLParser.Character_String_Literal, PLpgSQLParser.BeginDollarStringConstant]: + self.state = 7107 + self.character_string() + pass + else: + raise NoViableAltException(self) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Comp_optionsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def HASH_SIGN(self): + return self.getToken(PLpgSQLParser.HASH_SIGN, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def truth_value(self): + return self.getTypedRuleContext(PLpgSQLParser.Truth_valueContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_comp_options + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComp_options" ): + listener.enterComp_options(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComp_options" ): + listener.exitComp_options(self) + + + + + def comp_options(self): + + localctx = PLpgSQLParser.Comp_optionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 696, self.RULE_comp_options) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7112 + self.match(PLpgSQLParser.HASH_SIGN) + self.state = 7113 + self.identifier() + self.state = 7116 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 7114 + self.identifier() + pass + elif token in [PLpgSQLParser.FALSE, PLpgSQLParser.ON, PLpgSQLParser.TRUE]: + self.state = 7115 + self.truth_value() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_blockContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.end_label = None # IdentifierContext + + def BEGIN(self): + return self.getToken(PLpgSQLParser.BEGIN, 0) + + def function_statements(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_statementsContext,0) + + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def start_label(self): + return self.getTypedRuleContext(PLpgSQLParser.Start_labelContext,0) + + + def declarations(self): + return self.getTypedRuleContext(PLpgSQLParser.DeclarationsContext,0) + + + def exception_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Exception_statementContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_block + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_block" ): + listener.enterFunction_block(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_block" ): + listener.exitFunction_block(self) + + + + + def function_block(self): + + localctx = PLpgSQLParser.Function_blockContext(self, self._ctx, self.state) + self.enterRule(localctx, 698, self.RULE_function_block) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7119 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LESS_LESS: + self.state = 7118 + self.start_label() + + + self.state = 7122 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DECLARE: + self.state = 7121 + self.declarations() + + + self.state = 7124 + self.match(PLpgSQLParser.BEGIN) + self.state = 7125 + self.function_statements() + self.state = 7127 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.EXCEPTION: + self.state = 7126 + self.exception_statement() + + + self.state = 7129 + self.match(PLpgSQLParser.END) + self.state = 7131 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 7130 + localctx.end_label = self.identifier() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Start_labelContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LESS_LESS(self): + return self.getToken(PLpgSQLParser.LESS_LESS, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def GREATER_GREATER(self): + return self.getToken(PLpgSQLParser.GREATER_GREATER, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_start_label + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStart_label" ): + listener.enterStart_label(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStart_label" ): + listener.exitStart_label(self) + + + + + def start_label(self): + + localctx = PLpgSQLParser.Start_labelContext(self, self._ctx, self.state) + self.enterRule(localctx, 700, self.RULE_start_label) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7133 + self.match(PLpgSQLParser.LESS_LESS) + self.state = 7134 + self.identifier() + self.state = 7135 + self.match(PLpgSQLParser.GREATER_GREATER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DeclarationsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DECLARE(self): + return self.getToken(PLpgSQLParser.DECLARE, 0) + + def declaration(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.DeclarationContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.DeclarationContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_declarations + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDeclarations" ): + listener.enterDeclarations(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDeclarations" ): + listener.exitDeclarations(self) + + + + + def declarations(self): + + localctx = PLpgSQLParser.DeclarationsContext(self, self._ctx, self.state) + self.enterRule(localctx, 702, self.RULE_declarations) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7137 + self.match(PLpgSQLParser.DECLARE) + self.state = 7141 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,954,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 7138 + self.declaration() + self.state = 7143 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,954,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DeclarationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def type_declaration(self): + return self.getTypedRuleContext(PLpgSQLParser.Type_declarationContext,0) + + + def SEMI_COLON(self): + return self.getToken(PLpgSQLParser.SEMI_COLON, 0) + + def DECLARE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.DECLARE) + else: + return self.getToken(PLpgSQLParser.DECLARE, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_declaration + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDeclaration" ): + listener.enterDeclaration(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDeclaration" ): + listener.exitDeclaration(self) + + + + + def declaration(self): + + localctx = PLpgSQLParser.DeclarationContext(self, self._ctx, self.state) + self.enterRule(localctx, 704, self.RULE_declaration) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7147 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,955,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 7144 + self.match(PLpgSQLParser.DECLARE) + self.state = 7149 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,955,self._ctx) + + self.state = 7150 + self.identifier() + self.state = 7151 + self.type_declaration() + self.state = 7152 + self.match(PLpgSQLParser.SEMI_COLON) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Type_declarationContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_type_dec(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_type_decContext,0) + + + def CONSTANT(self): + return self.getToken(PLpgSQLParser.CONSTANT, 0) + + def collate_identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.Collate_identifierContext,0) + + + def NOT(self): + return self.getToken(PLpgSQLParser.NOT, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def DEFAULT(self): + return self.getToken(PLpgSQLParser.DEFAULT, 0) + + def COLON_EQUAL(self): + return self.getToken(PLpgSQLParser.COLON_EQUAL, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def ALIAS(self): + return self.getToken(PLpgSQLParser.ALIAS, 0) + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def DOLLAR_NUMBER(self): + return self.getToken(PLpgSQLParser.DOLLAR_NUMBER, 0) + + def CURSOR(self): + return self.getToken(PLpgSQLParser.CURSOR, 0) + + def select_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmtContext,0) + + + def IS(self): + return self.getToken(PLpgSQLParser.IS, 0) + + def SCROLL(self): + return self.getToken(PLpgSQLParser.SCROLL, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def arguments_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Arguments_listContext,0) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_type_declaration + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterType_declaration" ): + listener.enterType_declaration(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitType_declaration" ): + listener.exitType_declaration(self) + + + + + def type_declaration(self): + + localctx = PLpgSQLParser.Type_declarationContext(self, self._ctx, self.state) + self.enterRule(localctx, 706, self.RULE_type_declaration) + self._la = 0 # Token type + try: + self.state = 7190 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,964,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7155 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,956,self._ctx) + if la_ == 1: + self.state = 7154 + self.match(PLpgSQLParser.CONSTANT) + + + self.state = 7157 + self.data_type_dec() + self.state = 7159 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COLLATE: + self.state = 7158 + self.collate_identifier() + + + self.state = 7163 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NOT: + self.state = 7161 + self.match(PLpgSQLParser.NOT) + self.state = 7162 + self.match(PLpgSQLParser.NULL) + + + self.state = 7167 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.DEFAULT or _la==PLpgSQLParser.EQUAL or _la==PLpgSQLParser.COLON_EQUAL: + self.state = 7165 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.DEFAULT or _la==PLpgSQLParser.EQUAL or _la==PLpgSQLParser.COLON_EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7166 + self.vex(0) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7169 + self.match(PLpgSQLParser.ALIAS) + self.state = 7170 + self.match(PLpgSQLParser.FOR) + self.state = 7173 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 7171 + self.identifier() + pass + elif token in [PLpgSQLParser.DOLLAR_NUMBER]: + self.state = 7172 + self.match(PLpgSQLParser.DOLLAR_NUMBER) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7179 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO or _la==PLpgSQLParser.SCROLL: + self.state = 7176 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 7175 + self.match(PLpgSQLParser.NO) + + + self.state = 7178 + self.match(PLpgSQLParser.SCROLL) + + + self.state = 7181 + self.match(PLpgSQLParser.CURSOR) + self.state = 7186 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 7182 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 7183 + self.arguments_list() + self.state = 7184 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + self.state = 7188 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.IS or _la==PLpgSQLParser.FOR): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7189 + self.select_stmt() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Arguments_listContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def data_type(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Data_typeContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_arguments_list + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArguments_list" ): + listener.enterArguments_list(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArguments_list" ): + listener.exitArguments_list(self) + + + + + def arguments_list(self): + + localctx = PLpgSQLParser.Arguments_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 708, self.RULE_arguments_list) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7192 + self.identifier() + self.state = 7193 + self.data_type() + self.state = 7200 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7194 + self.match(PLpgSQLParser.COMMA) + self.state = 7195 + self.identifier() + self.state = 7196 + self.data_type() + self.state = 7202 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Data_type_decContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_type(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_typeContext,0) + + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def MODULAR(self): + return self.getToken(PLpgSQLParser.MODULAR, 0) + + def TYPE(self): + return self.getToken(PLpgSQLParser.TYPE, 0) + + def schema_qualified_name_nontype(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_name_nontypeContext,0) + + + def ROWTYPE(self): + return self.getToken(PLpgSQLParser.ROWTYPE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_data_type_dec + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterData_type_dec" ): + listener.enterData_type_dec(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitData_type_dec" ): + listener.exitData_type_dec(self) + + + + + def data_type_dec(self): + + localctx = PLpgSQLParser.Data_type_decContext(self, self._ctx, self.state) + self.enterRule(localctx, 710, self.RULE_data_type_dec) + try: + self.state = 7212 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,966,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7203 + self.data_type() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7204 + self.schema_qualified_name() + self.state = 7205 + self.match(PLpgSQLParser.MODULAR) + self.state = 7206 + self.match(PLpgSQLParser.TYPE) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7208 + self.schema_qualified_name_nontype() + self.state = 7209 + self.match(PLpgSQLParser.MODULAR) + self.state = 7210 + self.match(PLpgSQLParser.ROWTYPE) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Exception_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXCEPTION(self): + return self.getToken(PLpgSQLParser.EXCEPTION, 0) + + def WHEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WHEN) + else: + return self.getToken(PLpgSQLParser.WHEN, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def THEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.THEN) + else: + return self.getToken(PLpgSQLParser.THEN, i) + + def function_statements(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_statementsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_statementsContext,i) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_exception_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterException_statement" ): + listener.enterException_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitException_statement" ): + listener.exitException_statement(self) + + + + + def exception_statement(self): + + localctx = PLpgSQLParser.Exception_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 712, self.RULE_exception_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7214 + self.match(PLpgSQLParser.EXCEPTION) + self.state = 7220 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 7215 + self.match(PLpgSQLParser.WHEN) + self.state = 7216 + self.vex(0) + self.state = 7217 + self.match(PLpgSQLParser.THEN) + self.state = 7218 + self.function_statements() + self.state = 7222 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.WHEN): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_statementsContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def function_statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_statementContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_statementContext,i) + + + def SEMI_COLON(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.SEMI_COLON) + else: + return self.getToken(PLpgSQLParser.SEMI_COLON, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_statements + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_statements" ): + listener.enterFunction_statements(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_statements" ): + listener.exitFunction_statements(self) + + + + + def function_statements(self): + + localctx = PLpgSQLParser.Function_statementsContext(self, self._ctx, self.state) + self.enterRule(localctx, 714, self.RULE_function_statements) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7229 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,968,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 7224 + self.function_statement() + self.state = 7225 + self.match(PLpgSQLParser.SEMI_COLON) + self.state = 7231 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,968,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def function_block(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_blockContext,0) + + + def base_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Base_statementContext,0) + + + def control_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Control_statementContext,0) + + + def transaction_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Transaction_statementContext,0) + + + def cursor_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Cursor_statementContext,0) + + + def message_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Message_statementContext,0) + + + def schema_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_statementContext,0) + + + def plpgsql_query(self): + return self.getTypedRuleContext(PLpgSQLParser.Plpgsql_queryContext,0) + + + def additional_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Additional_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_function_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_statement" ): + listener.enterFunction_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_statement" ): + listener.exitFunction_statement(self) + + + + + def function_statement(self): + + localctx = PLpgSQLParser.Function_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 716, self.RULE_function_statement) + try: + self.state = 7241 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,969,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7232 + self.function_block() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7233 + self.base_statement() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7234 + self.control_statement() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 7235 + self.transaction_statement() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 7236 + self.cursor_statement() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 7237 + self.message_statement() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 7238 + self.schema_statement() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 7239 + self.plpgsql_query() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 7240 + self.additional_statement() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Base_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def assign_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Assign_stmtContext,0) + + + def PERFORM(self): + return self.getToken(PLpgSQLParser.PERFORM, 0) + + def perform_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Perform_stmtContext,0) + + + def GET(self): + return self.getToken(PLpgSQLParser.GET, 0) + + def DIAGNOSTICS(self): + return self.getToken(PLpgSQLParser.DIAGNOSTICS, 0) + + def diagnostic_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Diagnostic_optionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Diagnostic_optionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def CURRENT(self): + return self.getToken(PLpgSQLParser.CURRENT, 0) + + def STACKED(self): + return self.getToken(PLpgSQLParser.STACKED, 0) + + def NULL(self): + return self.getToken(PLpgSQLParser.NULL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_base_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBase_statement" ): + listener.enterBase_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBase_statement" ): + listener.exitBase_statement(self) + + + + + def base_statement(self): + + localctx = PLpgSQLParser.Base_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 718, self.RULE_base_statement) + self._la = 0 # Token type + try: + self.state = 7260 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,972,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7243 + self.assign_stmt() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7244 + self.match(PLpgSQLParser.PERFORM) + self.state = 7245 + self.perform_stmt() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7246 + self.match(PLpgSQLParser.GET) + self.state = 7248 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.CURRENT or _la==PLpgSQLParser.STACKED: + self.state = 7247 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CURRENT or _la==PLpgSQLParser.STACKED): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 7250 + self.match(PLpgSQLParser.DIAGNOSTICS) + self.state = 7251 + self.diagnostic_option() + self.state = 7256 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7252 + self.match(PLpgSQLParser.COMMA) + self.state = 7253 + self.diagnostic_option() + self.state = 7258 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 7259 + self.match(PLpgSQLParser.NULL) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VarContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def schema_qualified_name(self): + return self.getTypedRuleContext(PLpgSQLParser.Schema_qualified_nameContext,0) + + + def DOLLAR_NUMBER(self): + return self.getToken(PLpgSQLParser.DOLLAR_NUMBER, 0) + + def LEFT_BRACKET(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LEFT_BRACKET) + else: + return self.getToken(PLpgSQLParser.LEFT_BRACKET, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def RIGHT_BRACKET(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.RIGHT_BRACKET) + else: + return self.getToken(PLpgSQLParser.RIGHT_BRACKET, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_var + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVar" ): + listener.enterVar(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVar" ): + listener.exitVar(self) + + + + + def var(self): + + localctx = PLpgSQLParser.VarContext(self, self._ctx, self.state) + self.enterRule(localctx, 720, self.RULE_var) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7264 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.ABORT, PLpgSQLParser.ABSOLUTE, PLpgSQLParser.ACCESS, PLpgSQLParser.ACTION, PLpgSQLParser.ADD, PLpgSQLParser.ADMIN, PLpgSQLParser.AFTER, PLpgSQLParser.AGGREGATE, PLpgSQLParser.ALSO, PLpgSQLParser.ALTER, PLpgSQLParser.ALWAYS, PLpgSQLParser.ASSERTION, PLpgSQLParser.ASSIGNMENT, PLpgSQLParser.AT, PLpgSQLParser.ATTACH, PLpgSQLParser.ATTRIBUTE, PLpgSQLParser.BACKWARD, PLpgSQLParser.BEFORE, PLpgSQLParser.BEGIN, PLpgSQLParser.BY, PLpgSQLParser.CACHE, PLpgSQLParser.CALL, PLpgSQLParser.CALLED, PLpgSQLParser.CASCADE, PLpgSQLParser.CASCADED, PLpgSQLParser.CATALOG, PLpgSQLParser.CHAIN, PLpgSQLParser.CHARACTERISTICS, PLpgSQLParser.CHECKPOINT, PLpgSQLParser.CLASS, PLpgSQLParser.CLOSE, PLpgSQLParser.CLUSTER, PLpgSQLParser.COLUMNS, PLpgSQLParser.COMMENT, PLpgSQLParser.COMMENTS, PLpgSQLParser.COMMIT, PLpgSQLParser.COMMITTED, PLpgSQLParser.CONFIGURATION, PLpgSQLParser.CONFLICT, PLpgSQLParser.CONNECTION, PLpgSQLParser.CONSTRAINTS, PLpgSQLParser.CONTENT, PLpgSQLParser.CONTINUE, PLpgSQLParser.CONVERSION, PLpgSQLParser.COPY, PLpgSQLParser.COST, PLpgSQLParser.CSV, PLpgSQLParser.CUBE, PLpgSQLParser.CURRENT, PLpgSQLParser.CURSOR, PLpgSQLParser.CYCLE, PLpgSQLParser.DATA, PLpgSQLParser.DATABASE, PLpgSQLParser.DAY, PLpgSQLParser.DEALLOCATE, PLpgSQLParser.DECLARE, PLpgSQLParser.DEFAULTS, PLpgSQLParser.DEFERRED, PLpgSQLParser.DEFINER, PLpgSQLParser.DELETE, PLpgSQLParser.DELIMITER, PLpgSQLParser.DELIMITERS, PLpgSQLParser.DEPENDS, PLpgSQLParser.DETACH, PLpgSQLParser.DICTIONARY, PLpgSQLParser.DISABLE, PLpgSQLParser.DISCARD, PLpgSQLParser.DOCUMENT, PLpgSQLParser.DOMAIN, PLpgSQLParser.DOUBLE, PLpgSQLParser.DROP, PLpgSQLParser.EACH, PLpgSQLParser.ENABLE, PLpgSQLParser.ENCODING, PLpgSQLParser.ENCRYPTED, PLpgSQLParser.ENUM, PLpgSQLParser.ESCAPE, PLpgSQLParser.EVENT, PLpgSQLParser.EXCLUDE, PLpgSQLParser.EXCLUDING, PLpgSQLParser.EXCLUSIVE, PLpgSQLParser.EXECUTE, PLpgSQLParser.EXPLAIN, PLpgSQLParser.EXTENSION, PLpgSQLParser.EXTERNAL, PLpgSQLParser.FAMILY, PLpgSQLParser.FILTER, PLpgSQLParser.FIRST, PLpgSQLParser.FOLLOWING, PLpgSQLParser.FORCE, PLpgSQLParser.FORWARD, PLpgSQLParser.FUNCTION, PLpgSQLParser.FUNCTIONS, PLpgSQLParser.GENERATED, PLpgSQLParser.GLOBAL, PLpgSQLParser.GRANTED, PLpgSQLParser.GROUPS, PLpgSQLParser.HANDLER, PLpgSQLParser.HEADER, PLpgSQLParser.HOLD, PLpgSQLParser.HOUR, PLpgSQLParser.IDENTITY, PLpgSQLParser.IF, PLpgSQLParser.IMMEDIATE, PLpgSQLParser.IMMUTABLE, PLpgSQLParser.IMPLICIT, PLpgSQLParser.IMPORT, PLpgSQLParser.INCLUDE, PLpgSQLParser.INCLUDING, PLpgSQLParser.INCREMENT, PLpgSQLParser.INDEX, PLpgSQLParser.INDEXES, PLpgSQLParser.INHERIT, PLpgSQLParser.INHERITS, PLpgSQLParser.INLINE, PLpgSQLParser.INPUT, PLpgSQLParser.INSENSITIVE, PLpgSQLParser.INSERT, PLpgSQLParser.INSTEAD, PLpgSQLParser.INVOKER, PLpgSQLParser.ISOLATION, PLpgSQLParser.KEY, PLpgSQLParser.LABEL, PLpgSQLParser.LANGUAGE, PLpgSQLParser.LARGE, PLpgSQLParser.LAST, PLpgSQLParser.LEAKPROOF, PLpgSQLParser.LEVEL, PLpgSQLParser.LISTEN, PLpgSQLParser.LOAD, PLpgSQLParser.LOCAL, PLpgSQLParser.LOCATION, PLpgSQLParser.LOCK, PLpgSQLParser.LOCKED, PLpgSQLParser.LOGGED, PLpgSQLParser.MAPPING, PLpgSQLParser.MATCH, PLpgSQLParser.MATERIALIZED, PLpgSQLParser.MAXVALUE, PLpgSQLParser.METHOD, PLpgSQLParser.MINUTE, PLpgSQLParser.MINVALUE, PLpgSQLParser.MODE, PLpgSQLParser.MONTH, PLpgSQLParser.MOVE, PLpgSQLParser.NAME, PLpgSQLParser.NAMES, PLpgSQLParser.NEW, PLpgSQLParser.NEXT, PLpgSQLParser.NO, PLpgSQLParser.NOTHING, PLpgSQLParser.NOTIFY, PLpgSQLParser.NOWAIT, PLpgSQLParser.NULLS, PLpgSQLParser.OBJECT, PLpgSQLParser.OF, PLpgSQLParser.OFF, PLpgSQLParser.OIDS, PLpgSQLParser.OLD, PLpgSQLParser.OPERATOR, PLpgSQLParser.OPTION, PLpgSQLParser.OPTIONS, PLpgSQLParser.ORDINALITY, PLpgSQLParser.OTHERS, PLpgSQLParser.OVER, PLpgSQLParser.OVERRIDING, PLpgSQLParser.OWNED, PLpgSQLParser.OWNER, PLpgSQLParser.PARALLEL, PLpgSQLParser.PARSER, PLpgSQLParser.PARTIAL, PLpgSQLParser.PARTITION, PLpgSQLParser.PASSING, PLpgSQLParser.PASSWORD, PLpgSQLParser.PLANS, PLpgSQLParser.POLICY, PLpgSQLParser.PRECEDING, PLpgSQLParser.PREPARE, PLpgSQLParser.PREPARED, PLpgSQLParser.PRESERVE, PLpgSQLParser.PRIOR, PLpgSQLParser.PRIVILEGES, PLpgSQLParser.PROCEDURAL, PLpgSQLParser.PROCEDURE, PLpgSQLParser.PROCEDURES, PLpgSQLParser.PROGRAM, PLpgSQLParser.PUBLICATION, PLpgSQLParser.QUOTE, PLpgSQLParser.RANGE, PLpgSQLParser.READ, PLpgSQLParser.REASSIGN, PLpgSQLParser.RECHECK, PLpgSQLParser.RECURSIVE, PLpgSQLParser.REF, PLpgSQLParser.REFERENCING, PLpgSQLParser.REFRESH, PLpgSQLParser.REINDEX, PLpgSQLParser.RELATIVE, PLpgSQLParser.RELEASE, PLpgSQLParser.RENAME, PLpgSQLParser.REPEATABLE, PLpgSQLParser.REPLACE, PLpgSQLParser.REPLICA, PLpgSQLParser.RESET, PLpgSQLParser.RESTART, PLpgSQLParser.RESTRICT, PLpgSQLParser.RETURNS, PLpgSQLParser.REVOKE, PLpgSQLParser.ROLE, PLpgSQLParser.ROLLBACK, PLpgSQLParser.ROLLUP, PLpgSQLParser.ROUTINE, PLpgSQLParser.ROUTINES, PLpgSQLParser.ROWS, PLpgSQLParser.RULE, PLpgSQLParser.SAVEPOINT, PLpgSQLParser.SCHEMA, PLpgSQLParser.SCHEMAS, PLpgSQLParser.SCROLL, PLpgSQLParser.SEARCH, PLpgSQLParser.SECOND, PLpgSQLParser.SECURITY, PLpgSQLParser.SEQUENCE, PLpgSQLParser.SEQUENCES, PLpgSQLParser.SERIALIZABLE, PLpgSQLParser.SERVER, PLpgSQLParser.SESSION, PLpgSQLParser.SET, PLpgSQLParser.SETS, PLpgSQLParser.SHARE, PLpgSQLParser.SHOW, PLpgSQLParser.SIMPLE, PLpgSQLParser.SKIP_, PLpgSQLParser.SNAPSHOT, PLpgSQLParser.SQL, PLpgSQLParser.STABLE, PLpgSQLParser.STANDALONE, PLpgSQLParser.START, PLpgSQLParser.STATEMENT, PLpgSQLParser.STATISTICS, PLpgSQLParser.STDIN, PLpgSQLParser.STDOUT, PLpgSQLParser.STORAGE, PLpgSQLParser.STORED, PLpgSQLParser.STRICT, PLpgSQLParser.STRIP, PLpgSQLParser.SUBSCRIPTION, PLpgSQLParser.SUPPORT, PLpgSQLParser.SYSID, PLpgSQLParser.SYSTEM, PLpgSQLParser.TABLES, PLpgSQLParser.TABLESPACE, PLpgSQLParser.TEMP, PLpgSQLParser.TEMPLATE, PLpgSQLParser.TEMPORARY, PLpgSQLParser.TEXT, PLpgSQLParser.TIES, PLpgSQLParser.TRANSACTION, PLpgSQLParser.TRANSFORM, PLpgSQLParser.TRIGGER, PLpgSQLParser.TRUNCATE, PLpgSQLParser.TRUSTED, PLpgSQLParser.TYPE, PLpgSQLParser.TYPES, PLpgSQLParser.UNBOUNDED, PLpgSQLParser.UNCOMMITTED, PLpgSQLParser.UNENCRYPTED, PLpgSQLParser.UNKNOWN, PLpgSQLParser.UNLISTEN, PLpgSQLParser.UNLOGGED, PLpgSQLParser.UNTIL, PLpgSQLParser.UPDATE, PLpgSQLParser.VACUUM, PLpgSQLParser.VALID, PLpgSQLParser.VALIDATE, PLpgSQLParser.VALIDATOR, PLpgSQLParser.VALUE, PLpgSQLParser.VARYING, PLpgSQLParser.VERSION, PLpgSQLParser.VIEW, PLpgSQLParser.VIEWS, PLpgSQLParser.VOLATILE, PLpgSQLParser.WHITESPACE, PLpgSQLParser.WITHIN, PLpgSQLParser.WITHOUT, PLpgSQLParser.WORK, PLpgSQLParser.WRAPPER, PLpgSQLParser.WRITE, PLpgSQLParser.XML, PLpgSQLParser.YEAR, PLpgSQLParser.YES, PLpgSQLParser.ZONE, PLpgSQLParser.BETWEEN, PLpgSQLParser.BIGINT, PLpgSQLParser.BIT, PLpgSQLParser.BOOLEAN, PLpgSQLParser.CHAR, PLpgSQLParser.CHARACTER, PLpgSQLParser.COALESCE, PLpgSQLParser.DEC, PLpgSQLParser.DECIMAL, PLpgSQLParser.EXISTS, PLpgSQLParser.EXTRACT, PLpgSQLParser.FLOAT, PLpgSQLParser.GREATEST, PLpgSQLParser.GROUPING, PLpgSQLParser.INOUT, PLpgSQLParser.INT, PLpgSQLParser.INTEGER, PLpgSQLParser.INTERVAL, PLpgSQLParser.LEAST, PLpgSQLParser.NATIONAL, PLpgSQLParser.NCHAR, PLpgSQLParser.NONE, PLpgSQLParser.NULLIF, PLpgSQLParser.NUMERIC, PLpgSQLParser.OUT, PLpgSQLParser.OVERLAY, PLpgSQLParser.POSITION, PLpgSQLParser.PRECISION, PLpgSQLParser.REAL, PLpgSQLParser.ROW, PLpgSQLParser.SETOF, PLpgSQLParser.SMALLINT, PLpgSQLParser.SUBSTRING, PLpgSQLParser.TIME, PLpgSQLParser.TIMESTAMP, PLpgSQLParser.TREAT, PLpgSQLParser.TRIM, PLpgSQLParser.VALUES, PLpgSQLParser.VARCHAR, PLpgSQLParser.XMLATTRIBUTES, PLpgSQLParser.XMLCONCAT, PLpgSQLParser.XMLELEMENT, PLpgSQLParser.XMLEXISTS, PLpgSQLParser.XMLFOREST, PLpgSQLParser.XMLNAMESPACES, PLpgSQLParser.XMLPARSE, PLpgSQLParser.XMLPI, PLpgSQLParser.XMLROOT, PLpgSQLParser.XMLSERIALIZE, PLpgSQLParser.XMLTABLE, PLpgSQLParser.ALIGNMENT, PLpgSQLParser.BASETYPE, PLpgSQLParser.BUFFERS, PLpgSQLParser.BYPASSRLS, PLpgSQLParser.CANONICAL, PLpgSQLParser.CATEGORY, PLpgSQLParser.COLLATABLE, PLpgSQLParser.COMBINEFUNC, PLpgSQLParser.COMMUTATOR, PLpgSQLParser.CONNECT, PLpgSQLParser.COSTS, PLpgSQLParser.CREATEDB, PLpgSQLParser.CREATEROLE, PLpgSQLParser.DESERIALFUNC, PLpgSQLParser.DETERMINISTIC, PLpgSQLParser.DISABLE_PAGE_SKIPPING, PLpgSQLParser.ELEMENT, PLpgSQLParser.EXTENDED, PLpgSQLParser.FINALFUNC, PLpgSQLParser.FINALFUNC_EXTRA, PLpgSQLParser.FINALFUNC_MODIFY, PLpgSQLParser.FORCE_NOT_NULL, PLpgSQLParser.FORCE_NULL, PLpgSQLParser.FORCE_QUOTE, PLpgSQLParser.FORMAT, PLpgSQLParser.GETTOKEN, PLpgSQLParser.HASH, PLpgSQLParser.HASHES, PLpgSQLParser.HEADLINE, PLpgSQLParser.HYPOTHETICAL, PLpgSQLParser.INDEX_CLEANUP, PLpgSQLParser.INIT, PLpgSQLParser.INITCOND, PLpgSQLParser.INTERNALLENGTH, PLpgSQLParser.JSON, PLpgSQLParser.LC_COLLATE, PLpgSQLParser.LC_CTYPE, PLpgSQLParser.LEFTARG, PLpgSQLParser.LEXIZE, PLpgSQLParser.LEXTYPES, PLpgSQLParser.LIST, PLpgSQLParser.LOCALE, PLpgSQLParser.LOGIN, PLpgSQLParser.MAIN, PLpgSQLParser.MERGES, PLpgSQLParser.MFINALFUNC, PLpgSQLParser.MFINALFUNC_EXTRA, PLpgSQLParser.MFINALFUNC_MODIFY, PLpgSQLParser.MINITCOND, PLpgSQLParser.MINVFUNC, PLpgSQLParser.MODULUS, PLpgSQLParser.MSFUNC, PLpgSQLParser.MSSPACE, PLpgSQLParser.MSTYPE, PLpgSQLParser.NEGATOR, PLpgSQLParser.NOBYPASSRLS, PLpgSQLParser.NOCREATEDB, PLpgSQLParser.NOCREATEROLE, PLpgSQLParser.NOINHERIT, PLpgSQLParser.NOLOGIN, PLpgSQLParser.NOREPLICATION, PLpgSQLParser.NOSUPERUSER, PLpgSQLParser.OUTPUT, PLpgSQLParser.PASSEDBYVALUE, PLpgSQLParser.PATH, PLpgSQLParser.PERMISSIVE, PLpgSQLParser.PLAIN, PLpgSQLParser.PREFERRED, PLpgSQLParser.PROVIDER, PLpgSQLParser.READ_ONLY, PLpgSQLParser.READ_WRITE, PLpgSQLParser.RECEIVE, PLpgSQLParser.REMAINDER, PLpgSQLParser.REPLICATION, PLpgSQLParser.RESTRICTED, PLpgSQLParser.RESTRICTIVE, PLpgSQLParser.RIGHTARG, PLpgSQLParser.SAFE, PLpgSQLParser.SEND, PLpgSQLParser.SERIALFUNC, PLpgSQLParser.SETTINGS, PLpgSQLParser.SFUNC, PLpgSQLParser.SHAREABLE, PLpgSQLParser.SKIP_LOCKED, PLpgSQLParser.SORTOP, PLpgSQLParser.SSPACE, PLpgSQLParser.STYPE, PLpgSQLParser.SUBTYPE_DIFF, PLpgSQLParser.SUBTYPE_OPCLASS, PLpgSQLParser.SUBTYPE, PLpgSQLParser.SUMMARY, PLpgSQLParser.SUPERUSER, PLpgSQLParser.TIMING, PLpgSQLParser.TYPMOD_IN, PLpgSQLParser.TYPMOD_OUT, PLpgSQLParser.UNSAFE, PLpgSQLParser.USAGE, PLpgSQLParser.VARIABLE, PLpgSQLParser.YAML, PLpgSQLParser.ALIAS, PLpgSQLParser.ASSERT, PLpgSQLParser.CONSTANT, PLpgSQLParser.DATATYPE, PLpgSQLParser.DEBUG, PLpgSQLParser.DETAIL, PLpgSQLParser.DIAGNOSTICS, PLpgSQLParser.ELSEIF, PLpgSQLParser.ELSIF, PLpgSQLParser.ERRCODE, PLpgSQLParser.EXIT, PLpgSQLParser.EXCEPTION, PLpgSQLParser.FOREACH, PLpgSQLParser.GET, PLpgSQLParser.HINT, PLpgSQLParser.INFO, PLpgSQLParser.LOG, PLpgSQLParser.LOOP, PLpgSQLParser.MESSAGE, PLpgSQLParser.NOTICE, PLpgSQLParser.OPEN, PLpgSQLParser.PERFORM, PLpgSQLParser.QUERY, PLpgSQLParser.RAISE, PLpgSQLParser.RECORD, PLpgSQLParser.RETURN, PLpgSQLParser.REVERSE, PLpgSQLParser.ROWTYPE, PLpgSQLParser.SLICE, PLpgSQLParser.SQLSTATE, PLpgSQLParser.STACKED, PLpgSQLParser.WARNING, PLpgSQLParser.WHILE, PLpgSQLParser.Identifier, PLpgSQLParser.QuotedIdentifier]: + self.state = 7262 + self.schema_qualified_name() + pass + elif token in [PLpgSQLParser.DOLLAR_NUMBER]: + self.state = 7263 + self.match(PLpgSQLParser.DOLLAR_NUMBER) + pass + else: + raise NoViableAltException(self) + + self.state = 7272 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.LEFT_BRACKET: + self.state = 7266 + self.match(PLpgSQLParser.LEFT_BRACKET) + self.state = 7267 + self.vex(0) + self.state = 7268 + self.match(PLpgSQLParser.RIGHT_BRACKET) + self.state = 7274 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Diagnostic_optionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def var(self): + return self.getTypedRuleContext(PLpgSQLParser.VarContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def COLON_EQUAL(self): + return self.getToken(PLpgSQLParser.COLON_EQUAL, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_diagnostic_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDiagnostic_option" ): + listener.enterDiagnostic_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDiagnostic_option" ): + listener.exitDiagnostic_option(self) + + + + + def diagnostic_option(self): + + localctx = PLpgSQLParser.Diagnostic_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 722, self.RULE_diagnostic_option) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7275 + self.var() + self.state = 7276 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.EQUAL or _la==PLpgSQLParser.COLON_EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7277 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Perform_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def select_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_listContext,0) + + + def set_qualifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Set_qualifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Set_qualifierContext,i) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def from_item(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.From_itemContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.From_itemContext,i) + + + def WHERE(self): + return self.getToken(PLpgSQLParser.WHERE, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def groupby_clause(self): + return self.getTypedRuleContext(PLpgSQLParser.Groupby_clauseContext,0) + + + def HAVING(self): + return self.getToken(PLpgSQLParser.HAVING, 0) + + def WINDOW(self): + return self.getToken(PLpgSQLParser.WINDOW, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def AS(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.AS) + else: + return self.getToken(PLpgSQLParser.AS, i) + + def window_definition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Window_definitionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Window_definitionContext,i) + + + def select_ops(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_opsContext,0) + + + def after_ops(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.After_opsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.After_opsContext,i) + + + def INTERSECT(self): + return self.getToken(PLpgSQLParser.INTERSECT, 0) + + def UNION(self): + return self.getToken(PLpgSQLParser.UNION, 0) + + def EXCEPT(self): + return self.getToken(PLpgSQLParser.EXCEPT, 0) + + def ON(self): + return self.getToken(PLpgSQLParser.ON, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_perform_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerform_stmt" ): + listener.enterPerform_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerform_stmt" ): + listener.exitPerform_stmt(self) + + + + + def perform_stmt(self): + + localctx = PLpgSQLParser.Perform_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 724, self.RULE_perform_stmt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7294 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,977,self._ctx) + if la_ == 1: + self.state = 7279 + self.set_qualifier() + self.state = 7292 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,976,self._ctx) + if la_ == 1: + self.state = 7280 + self.match(PLpgSQLParser.ON) + self.state = 7281 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 7282 + self.vex(0) + self.state = 7287 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7283 + self.match(PLpgSQLParser.COMMA) + self.state = 7284 + self.vex(0) + self.state = 7289 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7290 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + + + self.state = 7296 + self.select_list() + self.state = 7306 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM: + self.state = 7297 + self.match(PLpgSQLParser.FROM) + self.state = 7298 + self.from_item(0) + self.state = 7303 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7299 + self.match(PLpgSQLParser.COMMA) + self.state = 7300 + self.from_item(0) + self.state = 7305 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 7310 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHERE: + self.state = 7308 + self.match(PLpgSQLParser.WHERE) + self.state = 7309 + self.vex(0) + + + self.state = 7313 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.GROUP: + self.state = 7312 + self.groupby_clause() + + + self.state = 7317 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.HAVING: + self.state = 7315 + self.match(PLpgSQLParser.HAVING) + self.state = 7316 + self.vex(0) + + + self.state = 7333 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WINDOW: + self.state = 7319 + self.match(PLpgSQLParser.WINDOW) + self.state = 7320 + self.identifier() + self.state = 7321 + self.match(PLpgSQLParser.AS) + self.state = 7322 + self.window_definition() + self.state = 7330 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7323 + self.match(PLpgSQLParser.COMMA) + self.state = 7324 + self.identifier() + self.state = 7325 + self.match(PLpgSQLParser.AS) + self.state = 7326 + self.window_definition() + self.state = 7332 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 7340 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 396)) & ~0x3f) == 0 and ((1 << (_la - 396)) & ((1 << (PLpgSQLParser.EXCEPT - 396)) | (1 << (PLpgSQLParser.INTERSECT - 396)) | (1 << (PLpgSQLParser.UNION - 396)))) != 0): + self.state = 7335 + _la = self._input.LA(1) + if not(((((_la - 396)) & ~0x3f) == 0 and ((1 << (_la - 396)) & ((1 << (PLpgSQLParser.EXCEPT - 396)) | (1 << (PLpgSQLParser.INTERSECT - 396)) | (1 << (PLpgSQLParser.UNION - 396)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7337 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ALL or _la==PLpgSQLParser.DISTINCT: + self.state = 7336 + self.set_qualifier() + + + self.state = 7339 + self.select_ops(0) + + + self.state = 7345 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 398)) & ~0x3f) == 0 and ((1 << (_la - 398)) & ((1 << (PLpgSQLParser.FETCH - 398)) | (1 << (PLpgSQLParser.FOR - 398)) | (1 << (PLpgSQLParser.LIMIT - 398)) | (1 << (PLpgSQLParser.OFFSET - 398)) | (1 << (PLpgSQLParser.ORDER - 398)))) != 0): + self.state = 7342 + self.after_ops() + self.state = 7347 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Assign_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def var(self): + return self.getTypedRuleContext(PLpgSQLParser.VarContext,0) + + + def COLON_EQUAL(self): + return self.getToken(PLpgSQLParser.COLON_EQUAL, 0) + + def EQUAL(self): + return self.getToken(PLpgSQLParser.EQUAL, 0) + + def select_stmt_no_parens(self): + return self.getTypedRuleContext(PLpgSQLParser.Select_stmt_no_parensContext,0) + + + def perform_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Perform_stmtContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_assign_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAssign_stmt" ): + listener.enterAssign_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAssign_stmt" ): + listener.exitAssign_stmt(self) + + + + + def assign_stmt(self): + + localctx = PLpgSQLParser.Assign_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 726, self.RULE_assign_stmt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7348 + self.var() + self.state = 7349 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.EQUAL or _la==PLpgSQLParser.COLON_EQUAL): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7352 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,988,self._ctx) + if la_ == 1: + self.state = 7350 + self.select_stmt_no_parens() + pass + + elif la_ == 2: + self.state = 7351 + self.perform_stmt() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Execute_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXECUTE(self): + return self.getToken(PLpgSQLParser.EXECUTE, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def using_vex(self): + return self.getTypedRuleContext(PLpgSQLParser.Using_vexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_execute_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecute_stmt" ): + listener.enterExecute_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecute_stmt" ): + listener.exitExecute_stmt(self) + + + + + def execute_stmt(self): + + localctx = PLpgSQLParser.Execute_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 728, self.RULE_execute_stmt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7354 + self.match(PLpgSQLParser.EXECUTE) + self.state = 7355 + self.vex(0) + self.state = 7357 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 7356 + self.using_vex() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Control_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def return_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Return_stmtContext,0) + + + def CALL(self): + return self.getToken(PLpgSQLParser.CALL, 0) + + def function_call(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_callContext,0) + + + def if_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.If_statementContext,0) + + + def case_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Case_statementContext,0) + + + def loop_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Loop_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_control_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterControl_statement" ): + listener.enterControl_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitControl_statement" ): + listener.exitControl_statement(self) + + + + + def control_statement(self): + + localctx = PLpgSQLParser.Control_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 730, self.RULE_control_statement) + try: + self.state = 7365 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.RETURN]: + self.enterOuterAlt(localctx, 1) + self.state = 7359 + self.return_stmt() + pass + elif token in [PLpgSQLParser.CALL]: + self.enterOuterAlt(localctx, 2) + self.state = 7360 + self.match(PLpgSQLParser.CALL) + self.state = 7361 + self.function_call() + pass + elif token in [PLpgSQLParser.IF]: + self.enterOuterAlt(localctx, 3) + self.state = 7362 + self.if_statement() + pass + elif token in [PLpgSQLParser.CASE]: + self.enterOuterAlt(localctx, 4) + self.state = 7363 + self.case_statement() + pass + elif token in [PLpgSQLParser.CONTINUE, PLpgSQLParser.FOR, PLpgSQLParser.EXIT, PLpgSQLParser.FOREACH, PLpgSQLParser.LOOP, PLpgSQLParser.WHILE, PLpgSQLParser.LESS_LESS]: + self.enterOuterAlt(localctx, 5) + self.state = 7364 + self.loop_statement() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Cursor_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPEN(self): + return self.getToken(PLpgSQLParser.OPEN, 0) + + def var(self): + return self.getTypedRuleContext(PLpgSQLParser.VarContext,0) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def plpgsql_query(self): + return self.getTypedRuleContext(PLpgSQLParser.Plpgsql_queryContext,0) + + + def SCROLL(self): + return self.getToken(PLpgSQLParser.SCROLL, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.OptionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.OptionContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def FETCH(self): + return self.getToken(PLpgSQLParser.FETCH, 0) + + def fetch_move_direction(self): + return self.getTypedRuleContext(PLpgSQLParser.Fetch_move_directionContext,0) + + + def FROM(self): + return self.getToken(PLpgSQLParser.FROM, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def MOVE(self): + return self.getToken(PLpgSQLParser.MOVE, 0) + + def CLOSE(self): + return self.getToken(PLpgSQLParser.CLOSE, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_cursor_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCursor_statement" ): + listener.enterCursor_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCursor_statement" ): + listener.exitCursor_statement(self) + + + + + def cursor_statement(self): + + localctx = PLpgSQLParser.Cursor_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 732, self.RULE_cursor_statement) + self._la = 0 # Token type + try: + self.state = 7411 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,999,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7367 + self.match(PLpgSQLParser.OPEN) + self.state = 7368 + self.var() + self.state = 7373 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO or _la==PLpgSQLParser.SCROLL: + self.state = 7370 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 7369 + self.match(PLpgSQLParser.NO) + + + self.state = 7372 + self.match(PLpgSQLParser.SCROLL) + + + self.state = 7375 + self.match(PLpgSQLParser.FOR) + self.state = 7376 + self.plpgsql_query() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7378 + self.match(PLpgSQLParser.OPEN) + self.state = 7379 + self.var() + self.state = 7391 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 7380 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 7381 + self.option() + self.state = 7386 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7382 + self.match(PLpgSQLParser.COMMA) + self.state = 7383 + self.option() + self.state = 7388 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7389 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7393 + self.match(PLpgSQLParser.FETCH) + self.state = 7395 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,995,self._ctx) + if la_ == 1: + self.state = 7394 + self.fetch_move_direction() + + + self.state = 7398 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM or _la==PLpgSQLParser.IN: + self.state = 7397 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FROM or _la==PLpgSQLParser.IN): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 7400 + self.var() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 7401 + self.match(PLpgSQLParser.MOVE) + self.state = 7403 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,997,self._ctx) + if la_ == 1: + self.state = 7402 + self.fetch_move_direction() + + + self.state = 7406 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FROM or _la==PLpgSQLParser.IN: + self.state = 7405 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.FROM or _la==PLpgSQLParser.IN): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 7408 + self.var() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 7409 + self.match(PLpgSQLParser.CLOSE) + self.state = 7410 + self.var() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OptionContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def COLON_EQUAL(self): + return self.getToken(PLpgSQLParser.COLON_EQUAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption" ): + listener.enterOption(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption" ): + listener.exitOption(self) + + + + + def option(self): + + localctx = PLpgSQLParser.OptionContext(self, self._ctx, self.state) + self.enterRule(localctx, 734, self.RULE_option) + try: + self.enterOuterAlt(localctx, 1) + self.state = 7416 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,1000,self._ctx) + if la_ == 1: + self.state = 7413 + self.identifier() + self.state = 7414 + self.match(PLpgSQLParser.COLON_EQUAL) + + + self.state = 7418 + self.vex(0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Transaction_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMIT(self): + return self.getToken(PLpgSQLParser.COMMIT, 0) + + def ROLLBACK(self): + return self.getToken(PLpgSQLParser.ROLLBACK, 0) + + def AND(self): + return self.getToken(PLpgSQLParser.AND, 0) + + def CHAIN(self): + return self.getToken(PLpgSQLParser.CHAIN, 0) + + def NO(self): + return self.getToken(PLpgSQLParser.NO, 0) + + def lock_table(self): + return self.getTypedRuleContext(PLpgSQLParser.Lock_tableContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_transaction_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTransaction_statement" ): + listener.enterTransaction_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTransaction_statement" ): + listener.exitTransaction_statement(self) + + + + + def transaction_statement(self): + + localctx = PLpgSQLParser.Transaction_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 736, self.RULE_transaction_statement) + self._la = 0 # Token type + try: + self.state = 7429 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.COMMIT, PLpgSQLParser.ROLLBACK]: + self.enterOuterAlt(localctx, 1) + self.state = 7420 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.COMMIT or _la==PLpgSQLParser.ROLLBACK): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7426 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.AND: + self.state = 7421 + self.match(PLpgSQLParser.AND) + self.state = 7423 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.NO: + self.state = 7422 + self.match(PLpgSQLParser.NO) + + + self.state = 7425 + self.match(PLpgSQLParser.CHAIN) + + + pass + elif token in [PLpgSQLParser.LOCK]: + self.enterOuterAlt(localctx, 2) + self.state = 7428 + self.lock_table() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Message_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RAISE(self): + return self.getToken(PLpgSQLParser.RAISE, 0) + + def log_level(self): + return self.getTypedRuleContext(PLpgSQLParser.Log_levelContext,0) + + + def character_string(self): + return self.getTypedRuleContext(PLpgSQLParser.Character_stringContext,0) + + + def raise_using(self): + return self.getTypedRuleContext(PLpgSQLParser.Raise_usingContext,0) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def SQLSTATE(self): + return self.getToken(PLpgSQLParser.SQLSTATE, 0) + + def ASSERT(self): + return self.getToken(PLpgSQLParser.ASSERT, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_message_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMessage_statement" ): + listener.enterMessage_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMessage_statement" ): + listener.exitMessage_statement(self) + + + + + def message_statement(self): + + localctx = PLpgSQLParser.Message_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 738, self.RULE_message_statement) + self._la = 0 # Token type + try: + self.state = 7471 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,1013,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7431 + self.match(PLpgSQLParser.RAISE) + self.state = 7433 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 546)) & ~0x3f) == 0 and ((1 << (_la - 546)) & ((1 << (PLpgSQLParser.DEBUG - 546)) | (1 << (PLpgSQLParser.EXCEPTION - 546)) | (1 << (PLpgSQLParser.INFO - 546)) | (1 << (PLpgSQLParser.LOG - 546)) | (1 << (PLpgSQLParser.NOTICE - 546)) | (1 << (PLpgSQLParser.WARNING - 546)))) != 0): + self.state = 7432 + self.log_level() + + + self.state = 7443 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.Character_String_Literal or _la==PLpgSQLParser.BeginDollarStringConstant: + self.state = 7435 + self.character_string() + self.state = 7440 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7436 + self.match(PLpgSQLParser.COMMA) + self.state = 7437 + self.vex(0) + self.state = 7442 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 7446 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 7445 + self.raise_using() + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7448 + self.match(PLpgSQLParser.RAISE) + self.state = 7450 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,1008,self._ctx) + if la_ == 1: + self.state = 7449 + self.log_level() + + + self.state = 7452 + self.identifier() + self.state = 7454 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 7453 + self.raise_using() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7456 + self.match(PLpgSQLParser.RAISE) + self.state = 7458 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 546)) & ~0x3f) == 0 and ((1 << (_la - 546)) & ((1 << (PLpgSQLParser.DEBUG - 546)) | (1 << (PLpgSQLParser.EXCEPTION - 546)) | (1 << (PLpgSQLParser.INFO - 546)) | (1 << (PLpgSQLParser.LOG - 546)) | (1 << (PLpgSQLParser.NOTICE - 546)) | (1 << (PLpgSQLParser.WARNING - 546)))) != 0): + self.state = 7457 + self.log_level() + + + self.state = 7460 + self.match(PLpgSQLParser.SQLSTATE) + self.state = 7461 + self.character_string() + self.state = 7463 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.USING: + self.state = 7462 + self.raise_using() + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 7465 + self.match(PLpgSQLParser.ASSERT) + self.state = 7466 + self.vex(0) + self.state = 7469 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.COMMA: + self.state = 7467 + self.match(PLpgSQLParser.COMMA) + self.state = 7468 + self.vex(0) + + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Log_levelContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DEBUG(self): + return self.getToken(PLpgSQLParser.DEBUG, 0) + + def LOG(self): + return self.getToken(PLpgSQLParser.LOG, 0) + + def INFO(self): + return self.getToken(PLpgSQLParser.INFO, 0) + + def NOTICE(self): + return self.getToken(PLpgSQLParser.NOTICE, 0) + + def WARNING(self): + return self.getToken(PLpgSQLParser.WARNING, 0) + + def EXCEPTION(self): + return self.getToken(PLpgSQLParser.EXCEPTION, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_log_level + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLog_level" ): + listener.enterLog_level(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLog_level" ): + listener.exitLog_level(self) + + + + + def log_level(self): + + localctx = PLpgSQLParser.Log_levelContext(self, self._ctx, self.state) + self.enterRule(localctx, 740, self.RULE_log_level) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7473 + _la = self._input.LA(1) + if not(((((_la - 546)) & ~0x3f) == 0 and ((1 << (_la - 546)) & ((1 << (PLpgSQLParser.DEBUG - 546)) | (1 << (PLpgSQLParser.EXCEPTION - 546)) | (1 << (PLpgSQLParser.INFO - 546)) | (1 << (PLpgSQLParser.LOG - 546)) | (1 << (PLpgSQLParser.NOTICE - 546)) | (1 << (PLpgSQLParser.WARNING - 546)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Raise_usingContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def raise_param(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Raise_paramContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Raise_paramContext,i) + + + def EQUAL(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.EQUAL) + else: + return self.getToken(PLpgSQLParser.EQUAL, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_raise_using + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRaise_using" ): + listener.enterRaise_using(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRaise_using" ): + listener.exitRaise_using(self) + + + + + def raise_using(self): + + localctx = PLpgSQLParser.Raise_usingContext(self, self._ctx, self.state) + self.enterRule(localctx, 742, self.RULE_raise_using) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7475 + self.match(PLpgSQLParser.USING) + self.state = 7476 + self.raise_param() + self.state = 7477 + self.match(PLpgSQLParser.EQUAL) + self.state = 7478 + self.vex(0) + self.state = 7486 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7479 + self.match(PLpgSQLParser.COMMA) + self.state = 7480 + self.raise_param() + self.state = 7481 + self.match(PLpgSQLParser.EQUAL) + self.state = 7482 + self.vex(0) + self.state = 7488 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Raise_paramContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MESSAGE(self): + return self.getToken(PLpgSQLParser.MESSAGE, 0) + + def DETAIL(self): + return self.getToken(PLpgSQLParser.DETAIL, 0) + + def HINT(self): + return self.getToken(PLpgSQLParser.HINT, 0) + + def ERRCODE(self): + return self.getToken(PLpgSQLParser.ERRCODE, 0) + + def COLUMN(self): + return self.getToken(PLpgSQLParser.COLUMN, 0) + + def CONSTRAINT(self): + return self.getToken(PLpgSQLParser.CONSTRAINT, 0) + + def DATATYPE(self): + return self.getToken(PLpgSQLParser.DATATYPE, 0) + + def TABLE(self): + return self.getToken(PLpgSQLParser.TABLE, 0) + + def SCHEMA(self): + return self.getToken(PLpgSQLParser.SCHEMA, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_raise_param + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRaise_param" ): + listener.enterRaise_param(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRaise_param" ): + listener.exitRaise_param(self) + + + + + def raise_param(self): + + localctx = PLpgSQLParser.Raise_paramContext(self, self._ctx, self.state) + self.enterRule(localctx, 744, self.RULE_raise_param) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7489 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.SCHEMA or ((((_la - 380)) & ~0x3f) == 0 and ((1 << (_la - 380)) & ((1 << (PLpgSQLParser.COLUMN - 380)) | (1 << (PLpgSQLParser.CONSTRAINT - 380)) | (1 << (PLpgSQLParser.TABLE - 380)))) != 0) or ((((_la - 545)) & ~0x3f) == 0 and ((1 << (_la - 545)) & ((1 << (PLpgSQLParser.DATATYPE - 545)) | (1 << (PLpgSQLParser.DETAIL - 545)) | (1 << (PLpgSQLParser.ERRCODE - 545)) | (1 << (PLpgSQLParser.HINT - 545)) | (1 << (PLpgSQLParser.MESSAGE - 545)))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Return_stmtContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RETURN(self): + return self.getToken(PLpgSQLParser.RETURN, 0) + + def perform_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Perform_stmtContext,0) + + + def NEXT(self): + return self.getToken(PLpgSQLParser.NEXT, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def QUERY(self): + return self.getToken(PLpgSQLParser.QUERY, 0) + + def plpgsql_query(self): + return self.getTypedRuleContext(PLpgSQLParser.Plpgsql_queryContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_return_stmt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReturn_stmt" ): + listener.enterReturn_stmt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReturn_stmt" ): + listener.exitReturn_stmt(self) + + + + + def return_stmt(self): + + localctx = PLpgSQLParser.Return_stmtContext(self, self._ctx, self.state) + self.enterRule(localctx, 746, self.RULE_return_stmt) + self._la = 0 # Token type + try: + self.state = 7501 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,1016,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7491 + self.match(PLpgSQLParser.RETURN) + self.state = 7493 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.DISTINCT - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 7492 + self.perform_stmt() + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7495 + self.match(PLpgSQLParser.RETURN) + self.state = 7496 + self.match(PLpgSQLParser.NEXT) + self.state = 7497 + self.vex(0) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7498 + self.match(PLpgSQLParser.RETURN) + self.state = 7499 + self.match(PLpgSQLParser.QUERY) + self.state = 7500 + self.plpgsql_query() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Loop_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LOOP(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.LOOP) + else: + return self.getToken(PLpgSQLParser.LOOP, i) + + def function_statements(self): + return self.getTypedRuleContext(PLpgSQLParser.Function_statementsContext,0) + + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def start_label(self): + return self.getTypedRuleContext(PLpgSQLParser.Start_labelContext,0) + + + def loop_start(self): + return self.getTypedRuleContext(PLpgSQLParser.Loop_startContext,0) + + + def identifier(self): + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,0) + + + def EXIT(self): + return self.getToken(PLpgSQLParser.EXIT, 0) + + def CONTINUE(self): + return self.getToken(PLpgSQLParser.CONTINUE, 0) + + def WHEN(self): + return self.getToken(PLpgSQLParser.WHEN, 0) + + def vex(self): + return self.getTypedRuleContext(PLpgSQLParser.VexContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_loop_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLoop_statement" ): + listener.enterLoop_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLoop_statement" ): + listener.exitLoop_statement(self) + + + + + def loop_statement(self): + + localctx = PLpgSQLParser.Loop_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 748, self.RULE_loop_statement) + self._la = 0 # Token type + try: + self.state = 7524 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.FOR, PLpgSQLParser.FOREACH, PLpgSQLParser.LOOP, PLpgSQLParser.WHILE, PLpgSQLParser.LESS_LESS]: + self.enterOuterAlt(localctx, 1) + self.state = 7504 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LESS_LESS: + self.state = 7503 + self.start_label() + + + self.state = 7507 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.FOR or _la==PLpgSQLParser.FOREACH or _la==PLpgSQLParser.WHILE: + self.state = 7506 + self.loop_start() + + + self.state = 7509 + self.match(PLpgSQLParser.LOOP) + self.state = 7510 + self.function_statements() + self.state = 7511 + self.match(PLpgSQLParser.END) + self.state = 7512 + self.match(PLpgSQLParser.LOOP) + self.state = 7514 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 7513 + self.identifier() + + + pass + elif token in [PLpgSQLParser.CONTINUE, PLpgSQLParser.EXIT]: + self.enterOuterAlt(localctx, 2) + self.state = 7516 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.CONTINUE or _la==PLpgSQLParser.EXIT): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7518 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)))) != 0) or ((((_la - 443)) & ~0x3f) == 0 and ((1 << (_la - 443)) & ((1 << (PLpgSQLParser.ALIGNMENT - 443)) | (1 << (PLpgSQLParser.BASETYPE - 443)) | (1 << (PLpgSQLParser.BUFFERS - 443)) | (1 << (PLpgSQLParser.BYPASSRLS - 443)) | (1 << (PLpgSQLParser.CANONICAL - 443)) | (1 << (PLpgSQLParser.CATEGORY - 443)) | (1 << (PLpgSQLParser.COLLATABLE - 443)) | (1 << (PLpgSQLParser.COMBINEFUNC - 443)) | (1 << (PLpgSQLParser.COMMUTATOR - 443)) | (1 << (PLpgSQLParser.CONNECT - 443)) | (1 << (PLpgSQLParser.COSTS - 443)) | (1 << (PLpgSQLParser.CREATEDB - 443)) | (1 << (PLpgSQLParser.CREATEROLE - 443)) | (1 << (PLpgSQLParser.DESERIALFUNC - 443)) | (1 << (PLpgSQLParser.DETERMINISTIC - 443)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 443)) | (1 << (PLpgSQLParser.ELEMENT - 443)) | (1 << (PLpgSQLParser.EXTENDED - 443)) | (1 << (PLpgSQLParser.FINALFUNC - 443)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_NULL - 443)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 443)) | (1 << (PLpgSQLParser.FORMAT - 443)) | (1 << (PLpgSQLParser.GETTOKEN - 443)) | (1 << (PLpgSQLParser.HASH - 443)) | (1 << (PLpgSQLParser.HASHES - 443)) | (1 << (PLpgSQLParser.HEADLINE - 443)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 443)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 443)) | (1 << (PLpgSQLParser.INIT - 443)) | (1 << (PLpgSQLParser.INITCOND - 443)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 443)) | (1 << (PLpgSQLParser.JSON - 443)) | (1 << (PLpgSQLParser.LC_COLLATE - 443)) | (1 << (PLpgSQLParser.LC_CTYPE - 443)) | (1 << (PLpgSQLParser.LEFTARG - 443)) | (1 << (PLpgSQLParser.LEXIZE - 443)) | (1 << (PLpgSQLParser.LEXTYPES - 443)) | (1 << (PLpgSQLParser.LIST - 443)) | (1 << (PLpgSQLParser.LOCALE - 443)) | (1 << (PLpgSQLParser.LOGIN - 443)) | (1 << (PLpgSQLParser.MAIN - 443)) | (1 << (PLpgSQLParser.MERGES - 443)) | (1 << (PLpgSQLParser.MFINALFUNC - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 443)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 443)) | (1 << (PLpgSQLParser.MINITCOND - 443)) | (1 << (PLpgSQLParser.MINVFUNC - 443)) | (1 << (PLpgSQLParser.MODULUS - 443)) | (1 << (PLpgSQLParser.MSFUNC - 443)) | (1 << (PLpgSQLParser.MSSPACE - 443)) | (1 << (PLpgSQLParser.MSTYPE - 443)) | (1 << (PLpgSQLParser.NEGATOR - 443)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 443)) | (1 << (PLpgSQLParser.NOCREATEDB - 443)) | (1 << (PLpgSQLParser.NOCREATEROLE - 443)) | (1 << (PLpgSQLParser.NOINHERIT - 443)) | (1 << (PLpgSQLParser.NOLOGIN - 443)) | (1 << (PLpgSQLParser.NOREPLICATION - 443)) | (1 << (PLpgSQLParser.NOSUPERUSER - 443)) | (1 << (PLpgSQLParser.OUTPUT - 443)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 443)))) != 0) or ((((_la - 507)) & ~0x3f) == 0 and ((1 << (_la - 507)) & ((1 << (PLpgSQLParser.PATH - 507)) | (1 << (PLpgSQLParser.PERMISSIVE - 507)) | (1 << (PLpgSQLParser.PLAIN - 507)) | (1 << (PLpgSQLParser.PREFERRED - 507)) | (1 << (PLpgSQLParser.PROVIDER - 507)) | (1 << (PLpgSQLParser.READ_ONLY - 507)) | (1 << (PLpgSQLParser.READ_WRITE - 507)) | (1 << (PLpgSQLParser.RECEIVE - 507)) | (1 << (PLpgSQLParser.REMAINDER - 507)) | (1 << (PLpgSQLParser.REPLICATION - 507)) | (1 << (PLpgSQLParser.RESTRICTED - 507)) | (1 << (PLpgSQLParser.RESTRICTIVE - 507)) | (1 << (PLpgSQLParser.RIGHTARG - 507)) | (1 << (PLpgSQLParser.SAFE - 507)) | (1 << (PLpgSQLParser.SEND - 507)) | (1 << (PLpgSQLParser.SERIALFUNC - 507)) | (1 << (PLpgSQLParser.SETTINGS - 507)) | (1 << (PLpgSQLParser.SFUNC - 507)) | (1 << (PLpgSQLParser.SHAREABLE - 507)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 507)) | (1 << (PLpgSQLParser.SORTOP - 507)) | (1 << (PLpgSQLParser.SSPACE - 507)) | (1 << (PLpgSQLParser.STYPE - 507)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 507)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 507)) | (1 << (PLpgSQLParser.SUBTYPE - 507)) | (1 << (PLpgSQLParser.SUMMARY - 507)) | (1 << (PLpgSQLParser.SUPERUSER - 507)) | (1 << (PLpgSQLParser.TIMING - 507)) | (1 << (PLpgSQLParser.TYPMOD_IN - 507)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 507)) | (1 << (PLpgSQLParser.UNSAFE - 507)) | (1 << (PLpgSQLParser.USAGE - 507)) | (1 << (PLpgSQLParser.VARIABLE - 507)) | (1 << (PLpgSQLParser.YAML - 507)) | (1 << (PLpgSQLParser.ALIAS - 507)) | (1 << (PLpgSQLParser.ASSERT - 507)) | (1 << (PLpgSQLParser.CONSTANT - 507)) | (1 << (PLpgSQLParser.DATATYPE - 507)) | (1 << (PLpgSQLParser.DEBUG - 507)) | (1 << (PLpgSQLParser.DETAIL - 507)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 507)) | (1 << (PLpgSQLParser.ELSEIF - 507)) | (1 << (PLpgSQLParser.ELSIF - 507)) | (1 << (PLpgSQLParser.ERRCODE - 507)) | (1 << (PLpgSQLParser.EXIT - 507)) | (1 << (PLpgSQLParser.EXCEPTION - 507)) | (1 << (PLpgSQLParser.FOREACH - 507)) | (1 << (PLpgSQLParser.GET - 507)) | (1 << (PLpgSQLParser.HINT - 507)) | (1 << (PLpgSQLParser.INFO - 507)) | (1 << (PLpgSQLParser.LOG - 507)) | (1 << (PLpgSQLParser.LOOP - 507)) | (1 << (PLpgSQLParser.MESSAGE - 507)) | (1 << (PLpgSQLParser.NOTICE - 507)) | (1 << (PLpgSQLParser.OPEN - 507)) | (1 << (PLpgSQLParser.PERFORM - 507)) | (1 << (PLpgSQLParser.QUERY - 507)) | (1 << (PLpgSQLParser.RAISE - 507)) | (1 << (PLpgSQLParser.RECORD - 507)) | (1 << (PLpgSQLParser.RETURN - 507)) | (1 << (PLpgSQLParser.REVERSE - 507)) | (1 << (PLpgSQLParser.ROWTYPE - 507)) | (1 << (PLpgSQLParser.SLICE - 507)))) != 0) or ((((_la - 571)) & ~0x3f) == 0 and ((1 << (_la - 571)) & ((1 << (PLpgSQLParser.SQLSTATE - 571)) | (1 << (PLpgSQLParser.STACKED - 571)) | (1 << (PLpgSQLParser.WARNING - 571)) | (1 << (PLpgSQLParser.WHILE - 571)) | (1 << (PLpgSQLParser.Identifier - 571)) | (1 << (PLpgSQLParser.QuotedIdentifier - 571)))) != 0): + self.state = 7517 + self.identifier() + + + self.state = 7522 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.WHEN: + self.state = 7520 + self.match(PLpgSQLParser.WHEN) + self.state = 7521 + self.vex(0) + + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Loop_startContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.alias = None # IdentifierContext + self.cursor = None # IdentifierContext + + def WHILE(self): + return self.getToken(PLpgSQLParser.WHILE, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def FOR(self): + return self.getToken(PLpgSQLParser.FOR, 0) + + def IN(self): + return self.getToken(PLpgSQLParser.IN, 0) + + def DOUBLE_DOT(self): + return self.getToken(PLpgSQLParser.DOUBLE_DOT, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.IdentifierContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.IdentifierContext,i) + + + def REVERSE(self): + return self.getToken(PLpgSQLParser.REVERSE, 0) + + def BY(self): + return self.getToken(PLpgSQLParser.BY, 0) + + def identifier_list(self): + return self.getTypedRuleContext(PLpgSQLParser.Identifier_listContext,0) + + + def plpgsql_query(self): + return self.getTypedRuleContext(PLpgSQLParser.Plpgsql_queryContext,0) + + + def LEFT_PAREN(self): + return self.getToken(PLpgSQLParser.LEFT_PAREN, 0) + + def option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.OptionContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.OptionContext,i) + + + def RIGHT_PAREN(self): + return self.getToken(PLpgSQLParser.RIGHT_PAREN, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def FOREACH(self): + return self.getToken(PLpgSQLParser.FOREACH, 0) + + def ARRAY(self): + return self.getToken(PLpgSQLParser.ARRAY, 0) + + def SLICE(self): + return self.getToken(PLpgSQLParser.SLICE, 0) + + def NUMBER_LITERAL(self): + return self.getToken(PLpgSQLParser.NUMBER_LITERAL, 0) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_loop_start + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLoop_start" ): + listener.enterLoop_start(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLoop_start" ): + listener.exitLoop_start(self) + + + + + def loop_start(self): + + localctx = PLpgSQLParser.Loop_startContext(self, self._ctx, self.state) + self.enterRule(localctx, 750, self.RULE_loop_start) + self._la = 0 # Token type + try: + self.state = 7573 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,1028,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 7526 + self.match(PLpgSQLParser.WHILE) + self.state = 7527 + self.vex(0) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 7528 + self.match(PLpgSQLParser.FOR) + self.state = 7529 + localctx.alias = self.identifier() + self.state = 7530 + self.match(PLpgSQLParser.IN) + self.state = 7532 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,1023,self._ctx) + if la_ == 1: + self.state = 7531 + self.match(PLpgSQLParser.REVERSE) + + + self.state = 7534 + self.vex(0) + self.state = 7535 + self.match(PLpgSQLParser.DOUBLE_DOT) + self.state = 7536 + self.vex(0) + self.state = 7539 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.BY: + self.state = 7537 + self.match(PLpgSQLParser.BY) + self.state = 7538 + self.vex(0) + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 7541 + self.match(PLpgSQLParser.FOR) + self.state = 7542 + self.identifier_list() + self.state = 7543 + self.match(PLpgSQLParser.IN) + self.state = 7544 + self.plpgsql_query() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 7546 + self.match(PLpgSQLParser.FOR) + self.state = 7547 + localctx.cursor = self.identifier() + self.state = 7548 + self.match(PLpgSQLParser.IN) + self.state = 7549 + self.identifier() + self.state = 7561 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.LEFT_PAREN: + self.state = 7550 + self.match(PLpgSQLParser.LEFT_PAREN) + self.state = 7551 + self.option() + self.state = 7556 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7552 + self.match(PLpgSQLParser.COMMA) + self.state = 7553 + self.option() + self.state = 7558 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7559 + self.match(PLpgSQLParser.RIGHT_PAREN) + + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 7563 + self.match(PLpgSQLParser.FOREACH) + self.state = 7564 + self.identifier_list() + self.state = 7567 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.SLICE: + self.state = 7565 + self.match(PLpgSQLParser.SLICE) + self.state = 7566 + self.match(PLpgSQLParser.NUMBER_LITERAL) + + + self.state = 7569 + self.match(PLpgSQLParser.IN) + self.state = 7570 + self.match(PLpgSQLParser.ARRAY) + self.state = 7571 + self.vex(0) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Using_vexContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(PLpgSQLParser.USING, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_using_vex + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUsing_vex" ): + listener.enterUsing_vex(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUsing_vex" ): + listener.exitUsing_vex(self) + + + + + def using_vex(self): + + localctx = PLpgSQLParser.Using_vexContext(self, self._ctx, self.state) + self.enterRule(localctx, 752, self.RULE_using_vex) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7575 + self.match(PLpgSQLParser.USING) + self.state = 7576 + self.vex(0) + self.state = 7581 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7577 + self.match(PLpgSQLParser.COMMA) + self.state = 7578 + self.vex(0) + self.state = 7583 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class If_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def IF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.IF) + else: + return self.getToken(PLpgSQLParser.IF, i) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def THEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.THEN) + else: + return self.getToken(PLpgSQLParser.THEN, i) + + def function_statements(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_statementsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_statementsContext,i) + + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def ELSE(self): + return self.getToken(PLpgSQLParser.ELSE, 0) + + def ELSIF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ELSIF) + else: + return self.getToken(PLpgSQLParser.ELSIF, i) + + def ELSEIF(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.ELSEIF) + else: + return self.getToken(PLpgSQLParser.ELSEIF, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_if_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIf_statement" ): + listener.enterIf_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIf_statement" ): + listener.exitIf_statement(self) + + + + + def if_statement(self): + + localctx = PLpgSQLParser.If_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 754, self.RULE_if_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7584 + self.match(PLpgSQLParser.IF) + self.state = 7585 + self.vex(0) + self.state = 7586 + self.match(PLpgSQLParser.THEN) + self.state = 7587 + self.function_statements() + self.state = 7595 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.ELSEIF or _la==PLpgSQLParser.ELSIF: + self.state = 7588 + _la = self._input.LA(1) + if not(_la==PLpgSQLParser.ELSEIF or _la==PLpgSQLParser.ELSIF): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 7589 + self.vex(0) + self.state = 7590 + self.match(PLpgSQLParser.THEN) + self.state = 7591 + self.function_statements() + self.state = 7597 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7600 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ELSE: + self.state = 7598 + self.match(PLpgSQLParser.ELSE) + self.state = 7599 + self.function_statements() + + + self.state = 7602 + self.match(PLpgSQLParser.END) + self.state = 7603 + self.match(PLpgSQLParser.IF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Case_statementContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CASE(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.CASE) + else: + return self.getToken(PLpgSQLParser.CASE, i) + + def END(self): + return self.getToken(PLpgSQLParser.END, 0) + + def vex(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.VexContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.VexContext,i) + + + def WHEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.WHEN) + else: + return self.getToken(PLpgSQLParser.WHEN, i) + + def THEN(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.THEN) + else: + return self.getToken(PLpgSQLParser.THEN, i) + + def function_statements(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(PLpgSQLParser.Function_statementsContext) + else: + return self.getTypedRuleContext(PLpgSQLParser.Function_statementsContext,i) + + + def ELSE(self): + return self.getToken(PLpgSQLParser.ELSE, 0) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(PLpgSQLParser.COMMA) + else: + return self.getToken(PLpgSQLParser.COMMA, i) + + def getRuleIndex(self): + return PLpgSQLParser.RULE_case_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCase_statement" ): + listener.enterCase_statement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCase_statement" ): + listener.exitCase_statement(self) + + + + + def case_statement(self): + + localctx = PLpgSQLParser.Case_statementContext(self, self._ctx, self.state) + self.enterRule(localctx, 756, self.RULE_case_statement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 7605 + self.match(PLpgSQLParser.CASE) + self.state = 7607 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PLpgSQLParser.ABORT) | (1 << PLpgSQLParser.ABSOLUTE) | (1 << PLpgSQLParser.ACCESS) | (1 << PLpgSQLParser.ACTION) | (1 << PLpgSQLParser.ADD) | (1 << PLpgSQLParser.ADMIN) | (1 << PLpgSQLParser.AFTER) | (1 << PLpgSQLParser.AGGREGATE) | (1 << PLpgSQLParser.ALSO) | (1 << PLpgSQLParser.ALTER) | (1 << PLpgSQLParser.ALWAYS) | (1 << PLpgSQLParser.ASSERTION) | (1 << PLpgSQLParser.ASSIGNMENT) | (1 << PLpgSQLParser.AT) | (1 << PLpgSQLParser.ATTACH) | (1 << PLpgSQLParser.ATTRIBUTE) | (1 << PLpgSQLParser.BACKWARD) | (1 << PLpgSQLParser.BEFORE) | (1 << PLpgSQLParser.BEGIN) | (1 << PLpgSQLParser.BY) | (1 << PLpgSQLParser.CACHE) | (1 << PLpgSQLParser.CALL) | (1 << PLpgSQLParser.CALLED) | (1 << PLpgSQLParser.CASCADE) | (1 << PLpgSQLParser.CASCADED) | (1 << PLpgSQLParser.CATALOG) | (1 << PLpgSQLParser.CHAIN) | (1 << PLpgSQLParser.CHARACTERISTICS) | (1 << PLpgSQLParser.CHECKPOINT) | (1 << PLpgSQLParser.CLASS) | (1 << PLpgSQLParser.CLOSE) | (1 << PLpgSQLParser.CLUSTER) | (1 << PLpgSQLParser.COLUMNS) | (1 << PLpgSQLParser.COMMENT) | (1 << PLpgSQLParser.COMMENTS) | (1 << PLpgSQLParser.COMMIT) | (1 << PLpgSQLParser.COMMITTED) | (1 << PLpgSQLParser.CONFIGURATION) | (1 << PLpgSQLParser.CONFLICT) | (1 << PLpgSQLParser.CONNECTION) | (1 << PLpgSQLParser.CONSTRAINTS) | (1 << PLpgSQLParser.CONTENT) | (1 << PLpgSQLParser.CONTINUE) | (1 << PLpgSQLParser.CONVERSION) | (1 << PLpgSQLParser.COPY) | (1 << PLpgSQLParser.COST) | (1 << PLpgSQLParser.CSV) | (1 << PLpgSQLParser.CUBE) | (1 << PLpgSQLParser.CURRENT) | (1 << PLpgSQLParser.CURSOR) | (1 << PLpgSQLParser.CYCLE) | (1 << PLpgSQLParser.DATA) | (1 << PLpgSQLParser.DATABASE) | (1 << PLpgSQLParser.DAY) | (1 << PLpgSQLParser.DEALLOCATE) | (1 << PLpgSQLParser.DECLARE) | (1 << PLpgSQLParser.DEFAULTS) | (1 << PLpgSQLParser.DEFERRED) | (1 << PLpgSQLParser.DEFINER) | (1 << PLpgSQLParser.DELETE) | (1 << PLpgSQLParser.DELIMITER) | (1 << PLpgSQLParser.DELIMITERS) | (1 << PLpgSQLParser.DEPENDS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (PLpgSQLParser.DETACH - 64)) | (1 << (PLpgSQLParser.DICTIONARY - 64)) | (1 << (PLpgSQLParser.DISABLE - 64)) | (1 << (PLpgSQLParser.DISCARD - 64)) | (1 << (PLpgSQLParser.DOCUMENT - 64)) | (1 << (PLpgSQLParser.DOMAIN - 64)) | (1 << (PLpgSQLParser.DOUBLE - 64)) | (1 << (PLpgSQLParser.DROP - 64)) | (1 << (PLpgSQLParser.EACH - 64)) | (1 << (PLpgSQLParser.ENABLE - 64)) | (1 << (PLpgSQLParser.ENCODING - 64)) | (1 << (PLpgSQLParser.ENCRYPTED - 64)) | (1 << (PLpgSQLParser.ENUM - 64)) | (1 << (PLpgSQLParser.ESCAPE - 64)) | (1 << (PLpgSQLParser.EVENT - 64)) | (1 << (PLpgSQLParser.EXCLUDE - 64)) | (1 << (PLpgSQLParser.EXCLUDING - 64)) | (1 << (PLpgSQLParser.EXCLUSIVE - 64)) | (1 << (PLpgSQLParser.EXECUTE - 64)) | (1 << (PLpgSQLParser.EXPLAIN - 64)) | (1 << (PLpgSQLParser.EXTENSION - 64)) | (1 << (PLpgSQLParser.EXTERNAL - 64)) | (1 << (PLpgSQLParser.FAMILY - 64)) | (1 << (PLpgSQLParser.FILTER - 64)) | (1 << (PLpgSQLParser.FIRST - 64)) | (1 << (PLpgSQLParser.FOLLOWING - 64)) | (1 << (PLpgSQLParser.FORCE - 64)) | (1 << (PLpgSQLParser.FORWARD - 64)) | (1 << (PLpgSQLParser.FUNCTION - 64)) | (1 << (PLpgSQLParser.FUNCTIONS - 64)) | (1 << (PLpgSQLParser.GENERATED - 64)) | (1 << (PLpgSQLParser.GLOBAL - 64)) | (1 << (PLpgSQLParser.GRANTED - 64)) | (1 << (PLpgSQLParser.GROUPS - 64)) | (1 << (PLpgSQLParser.HANDLER - 64)) | (1 << (PLpgSQLParser.HEADER - 64)) | (1 << (PLpgSQLParser.HOLD - 64)) | (1 << (PLpgSQLParser.HOUR - 64)) | (1 << (PLpgSQLParser.IDENTITY - 64)) | (1 << (PLpgSQLParser.IF - 64)) | (1 << (PLpgSQLParser.IMMEDIATE - 64)) | (1 << (PLpgSQLParser.IMMUTABLE - 64)) | (1 << (PLpgSQLParser.IMPLICIT - 64)) | (1 << (PLpgSQLParser.IMPORT - 64)) | (1 << (PLpgSQLParser.INCLUDE - 64)) | (1 << (PLpgSQLParser.INCLUDING - 64)) | (1 << (PLpgSQLParser.INCREMENT - 64)) | (1 << (PLpgSQLParser.INDEX - 64)) | (1 << (PLpgSQLParser.INDEXES - 64)) | (1 << (PLpgSQLParser.INHERIT - 64)) | (1 << (PLpgSQLParser.INHERITS - 64)) | (1 << (PLpgSQLParser.INLINE - 64)) | (1 << (PLpgSQLParser.INPUT - 64)) | (1 << (PLpgSQLParser.INSENSITIVE - 64)) | (1 << (PLpgSQLParser.INSERT - 64)) | (1 << (PLpgSQLParser.INSTEAD - 64)) | (1 << (PLpgSQLParser.INVOKER - 64)) | (1 << (PLpgSQLParser.ISOLATION - 64)) | (1 << (PLpgSQLParser.KEY - 64)) | (1 << (PLpgSQLParser.LABEL - 64)) | (1 << (PLpgSQLParser.LANGUAGE - 64)) | (1 << (PLpgSQLParser.LARGE - 64)) | (1 << (PLpgSQLParser.LAST - 64)) | (1 << (PLpgSQLParser.LEAKPROOF - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (PLpgSQLParser.LEVEL - 128)) | (1 << (PLpgSQLParser.LISTEN - 128)) | (1 << (PLpgSQLParser.LOAD - 128)) | (1 << (PLpgSQLParser.LOCAL - 128)) | (1 << (PLpgSQLParser.LOCATION - 128)) | (1 << (PLpgSQLParser.LOCK - 128)) | (1 << (PLpgSQLParser.LOCKED - 128)) | (1 << (PLpgSQLParser.LOGGED - 128)) | (1 << (PLpgSQLParser.MAPPING - 128)) | (1 << (PLpgSQLParser.MATCH - 128)) | (1 << (PLpgSQLParser.MATERIALIZED - 128)) | (1 << (PLpgSQLParser.MAXVALUE - 128)) | (1 << (PLpgSQLParser.METHOD - 128)) | (1 << (PLpgSQLParser.MINUTE - 128)) | (1 << (PLpgSQLParser.MINVALUE - 128)) | (1 << (PLpgSQLParser.MODE - 128)) | (1 << (PLpgSQLParser.MONTH - 128)) | (1 << (PLpgSQLParser.MOVE - 128)) | (1 << (PLpgSQLParser.NAME - 128)) | (1 << (PLpgSQLParser.NAMES - 128)) | (1 << (PLpgSQLParser.NEW - 128)) | (1 << (PLpgSQLParser.NEXT - 128)) | (1 << (PLpgSQLParser.NO - 128)) | (1 << (PLpgSQLParser.NOTHING - 128)) | (1 << (PLpgSQLParser.NOTIFY - 128)) | (1 << (PLpgSQLParser.NOWAIT - 128)) | (1 << (PLpgSQLParser.NULLS - 128)) | (1 << (PLpgSQLParser.OBJECT - 128)) | (1 << (PLpgSQLParser.OF - 128)) | (1 << (PLpgSQLParser.OFF - 128)) | (1 << (PLpgSQLParser.OIDS - 128)) | (1 << (PLpgSQLParser.OLD - 128)) | (1 << (PLpgSQLParser.OPERATOR - 128)) | (1 << (PLpgSQLParser.OPTION - 128)) | (1 << (PLpgSQLParser.OPTIONS - 128)) | (1 << (PLpgSQLParser.ORDINALITY - 128)) | (1 << (PLpgSQLParser.OTHERS - 128)) | (1 << (PLpgSQLParser.OVER - 128)) | (1 << (PLpgSQLParser.OVERRIDING - 128)) | (1 << (PLpgSQLParser.OWNED - 128)) | (1 << (PLpgSQLParser.OWNER - 128)) | (1 << (PLpgSQLParser.PARALLEL - 128)) | (1 << (PLpgSQLParser.PARSER - 128)) | (1 << (PLpgSQLParser.PARTIAL - 128)) | (1 << (PLpgSQLParser.PARTITION - 128)) | (1 << (PLpgSQLParser.PASSING - 128)) | (1 << (PLpgSQLParser.PASSWORD - 128)) | (1 << (PLpgSQLParser.PLANS - 128)) | (1 << (PLpgSQLParser.POLICY - 128)) | (1 << (PLpgSQLParser.PRECEDING - 128)) | (1 << (PLpgSQLParser.PREPARE - 128)) | (1 << (PLpgSQLParser.PREPARED - 128)) | (1 << (PLpgSQLParser.PRESERVE - 128)) | (1 << (PLpgSQLParser.PRIOR - 128)) | (1 << (PLpgSQLParser.PRIVILEGES - 128)) | (1 << (PLpgSQLParser.PROCEDURAL - 128)) | (1 << (PLpgSQLParser.PROCEDURE - 128)) | (1 << (PLpgSQLParser.PROCEDURES - 128)) | (1 << (PLpgSQLParser.PROGRAM - 128)) | (1 << (PLpgSQLParser.PUBLICATION - 128)) | (1 << (PLpgSQLParser.QUOTE - 128)) | (1 << (PLpgSQLParser.RANGE - 128)) | (1 << (PLpgSQLParser.READ - 128)) | (1 << (PLpgSQLParser.REASSIGN - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (PLpgSQLParser.RECHECK - 192)) | (1 << (PLpgSQLParser.RECURSIVE - 192)) | (1 << (PLpgSQLParser.REF - 192)) | (1 << (PLpgSQLParser.REFERENCING - 192)) | (1 << (PLpgSQLParser.REFRESH - 192)) | (1 << (PLpgSQLParser.REINDEX - 192)) | (1 << (PLpgSQLParser.RELATIVE - 192)) | (1 << (PLpgSQLParser.RELEASE - 192)) | (1 << (PLpgSQLParser.RENAME - 192)) | (1 << (PLpgSQLParser.REPEATABLE - 192)) | (1 << (PLpgSQLParser.REPLACE - 192)) | (1 << (PLpgSQLParser.REPLICA - 192)) | (1 << (PLpgSQLParser.RESET - 192)) | (1 << (PLpgSQLParser.RESTART - 192)) | (1 << (PLpgSQLParser.RESTRICT - 192)) | (1 << (PLpgSQLParser.RETURNS - 192)) | (1 << (PLpgSQLParser.REVOKE - 192)) | (1 << (PLpgSQLParser.ROLE - 192)) | (1 << (PLpgSQLParser.ROLLBACK - 192)) | (1 << (PLpgSQLParser.ROLLUP - 192)) | (1 << (PLpgSQLParser.ROUTINE - 192)) | (1 << (PLpgSQLParser.ROUTINES - 192)) | (1 << (PLpgSQLParser.ROWS - 192)) | (1 << (PLpgSQLParser.RULE - 192)) | (1 << (PLpgSQLParser.SAVEPOINT - 192)) | (1 << (PLpgSQLParser.SCHEMA - 192)) | (1 << (PLpgSQLParser.SCHEMAS - 192)) | (1 << (PLpgSQLParser.SCROLL - 192)) | (1 << (PLpgSQLParser.SEARCH - 192)) | (1 << (PLpgSQLParser.SECOND - 192)) | (1 << (PLpgSQLParser.SECURITY - 192)) | (1 << (PLpgSQLParser.SEQUENCE - 192)) | (1 << (PLpgSQLParser.SEQUENCES - 192)) | (1 << (PLpgSQLParser.SERIALIZABLE - 192)) | (1 << (PLpgSQLParser.SERVER - 192)) | (1 << (PLpgSQLParser.SESSION - 192)) | (1 << (PLpgSQLParser.SET - 192)) | (1 << (PLpgSQLParser.SETS - 192)) | (1 << (PLpgSQLParser.SHARE - 192)) | (1 << (PLpgSQLParser.SHOW - 192)) | (1 << (PLpgSQLParser.SIMPLE - 192)) | (1 << (PLpgSQLParser.SKIP_ - 192)) | (1 << (PLpgSQLParser.SNAPSHOT - 192)) | (1 << (PLpgSQLParser.SQL - 192)) | (1 << (PLpgSQLParser.STABLE - 192)) | (1 << (PLpgSQLParser.STANDALONE - 192)) | (1 << (PLpgSQLParser.START - 192)) | (1 << (PLpgSQLParser.STATEMENT - 192)) | (1 << (PLpgSQLParser.STATISTICS - 192)) | (1 << (PLpgSQLParser.STDIN - 192)) | (1 << (PLpgSQLParser.STDOUT - 192)) | (1 << (PLpgSQLParser.STORAGE - 192)) | (1 << (PLpgSQLParser.STORED - 192)) | (1 << (PLpgSQLParser.STRICT - 192)) | (1 << (PLpgSQLParser.STRIP - 192)) | (1 << (PLpgSQLParser.SUBSCRIPTION - 192)) | (1 << (PLpgSQLParser.SUPPORT - 192)) | (1 << (PLpgSQLParser.SYSID - 192)) | (1 << (PLpgSQLParser.SYSTEM - 192)) | (1 << (PLpgSQLParser.TABLES - 192)) | (1 << (PLpgSQLParser.TABLESPACE - 192)) | (1 << (PLpgSQLParser.TEMP - 192)) | (1 << (PLpgSQLParser.TEMPLATE - 192)) | (1 << (PLpgSQLParser.TEMPORARY - 192)))) != 0) or ((((_la - 256)) & ~0x3f) == 0 and ((1 << (_la - 256)) & ((1 << (PLpgSQLParser.TEXT - 256)) | (1 << (PLpgSQLParser.TIES - 256)) | (1 << (PLpgSQLParser.TRANSACTION - 256)) | (1 << (PLpgSQLParser.TRANSFORM - 256)) | (1 << (PLpgSQLParser.TRIGGER - 256)) | (1 << (PLpgSQLParser.TRUNCATE - 256)) | (1 << (PLpgSQLParser.TRUSTED - 256)) | (1 << (PLpgSQLParser.TYPE - 256)) | (1 << (PLpgSQLParser.TYPES - 256)) | (1 << (PLpgSQLParser.UNBOUNDED - 256)) | (1 << (PLpgSQLParser.UNCOMMITTED - 256)) | (1 << (PLpgSQLParser.UNENCRYPTED - 256)) | (1 << (PLpgSQLParser.UNKNOWN - 256)) | (1 << (PLpgSQLParser.UNLISTEN - 256)) | (1 << (PLpgSQLParser.UNLOGGED - 256)) | (1 << (PLpgSQLParser.UNTIL - 256)) | (1 << (PLpgSQLParser.UPDATE - 256)) | (1 << (PLpgSQLParser.VACUUM - 256)) | (1 << (PLpgSQLParser.VALID - 256)) | (1 << (PLpgSQLParser.VALIDATE - 256)) | (1 << (PLpgSQLParser.VALIDATOR - 256)) | (1 << (PLpgSQLParser.VALUE - 256)) | (1 << (PLpgSQLParser.VARYING - 256)) | (1 << (PLpgSQLParser.VERSION - 256)) | (1 << (PLpgSQLParser.VIEW - 256)) | (1 << (PLpgSQLParser.VIEWS - 256)) | (1 << (PLpgSQLParser.VOLATILE - 256)) | (1 << (PLpgSQLParser.WHITESPACE - 256)) | (1 << (PLpgSQLParser.WITHIN - 256)) | (1 << (PLpgSQLParser.WITHOUT - 256)) | (1 << (PLpgSQLParser.WORK - 256)) | (1 << (PLpgSQLParser.WRAPPER - 256)) | (1 << (PLpgSQLParser.WRITE - 256)) | (1 << (PLpgSQLParser.XML - 256)) | (1 << (PLpgSQLParser.YEAR - 256)) | (1 << (PLpgSQLParser.YES - 256)) | (1 << (PLpgSQLParser.ZONE - 256)) | (1 << (PLpgSQLParser.BETWEEN - 256)) | (1 << (PLpgSQLParser.BIGINT - 256)) | (1 << (PLpgSQLParser.BIT - 256)) | (1 << (PLpgSQLParser.BOOLEAN - 256)) | (1 << (PLpgSQLParser.CHAR - 256)) | (1 << (PLpgSQLParser.CHARACTER - 256)) | (1 << (PLpgSQLParser.COALESCE - 256)) | (1 << (PLpgSQLParser.DEC - 256)) | (1 << (PLpgSQLParser.DECIMAL - 256)) | (1 << (PLpgSQLParser.EXISTS - 256)) | (1 << (PLpgSQLParser.EXTRACT - 256)) | (1 << (PLpgSQLParser.FLOAT - 256)) | (1 << (PLpgSQLParser.GREATEST - 256)) | (1 << (PLpgSQLParser.GROUPING - 256)) | (1 << (PLpgSQLParser.INOUT - 256)) | (1 << (PLpgSQLParser.INT - 256)) | (1 << (PLpgSQLParser.INTEGER - 256)) | (1 << (PLpgSQLParser.INTERVAL - 256)) | (1 << (PLpgSQLParser.LEAST - 256)) | (1 << (PLpgSQLParser.NATIONAL - 256)) | (1 << (PLpgSQLParser.NCHAR - 256)) | (1 << (PLpgSQLParser.NONE - 256)) | (1 << (PLpgSQLParser.NULLIF - 256)) | (1 << (PLpgSQLParser.NUMERIC - 256)) | (1 << (PLpgSQLParser.OUT - 256)) | (1 << (PLpgSQLParser.OVERLAY - 256)) | (1 << (PLpgSQLParser.POSITION - 256)))) != 0) or ((((_la - 320)) & ~0x3f) == 0 and ((1 << (_la - 320)) & ((1 << (PLpgSQLParser.PRECISION - 320)) | (1 << (PLpgSQLParser.REAL - 320)) | (1 << (PLpgSQLParser.ROW - 320)) | (1 << (PLpgSQLParser.SETOF - 320)) | (1 << (PLpgSQLParser.SMALLINT - 320)) | (1 << (PLpgSQLParser.SUBSTRING - 320)) | (1 << (PLpgSQLParser.TIME - 320)) | (1 << (PLpgSQLParser.TIMESTAMP - 320)) | (1 << (PLpgSQLParser.TREAT - 320)) | (1 << (PLpgSQLParser.TRIM - 320)) | (1 << (PLpgSQLParser.VALUES - 320)) | (1 << (PLpgSQLParser.VARCHAR - 320)) | (1 << (PLpgSQLParser.XMLATTRIBUTES - 320)) | (1 << (PLpgSQLParser.XMLCONCAT - 320)) | (1 << (PLpgSQLParser.XMLELEMENT - 320)) | (1 << (PLpgSQLParser.XMLEXISTS - 320)) | (1 << (PLpgSQLParser.XMLFOREST - 320)) | (1 << (PLpgSQLParser.XMLNAMESPACES - 320)) | (1 << (PLpgSQLParser.XMLPARSE - 320)) | (1 << (PLpgSQLParser.XMLPI - 320)) | (1 << (PLpgSQLParser.XMLROOT - 320)) | (1 << (PLpgSQLParser.XMLSERIALIZE - 320)) | (1 << (PLpgSQLParser.XMLTABLE - 320)) | (1 << (PLpgSQLParser.AUTHORIZATION - 320)) | (1 << (PLpgSQLParser.BINARY - 320)) | (1 << (PLpgSQLParser.COLLATION - 320)) | (1 << (PLpgSQLParser.CONCURRENTLY - 320)) | (1 << (PLpgSQLParser.CROSS - 320)) | (1 << (PLpgSQLParser.CURRENT_SCHEMA - 320)) | (1 << (PLpgSQLParser.FREEZE - 320)) | (1 << (PLpgSQLParser.FULL - 320)) | (1 << (PLpgSQLParser.ILIKE - 320)) | (1 << (PLpgSQLParser.INNER - 320)) | (1 << (PLpgSQLParser.IS - 320)) | (1 << (PLpgSQLParser.ISNULL - 320)) | (1 << (PLpgSQLParser.JOIN - 320)) | (1 << (PLpgSQLParser.LEFT - 320)) | (1 << (PLpgSQLParser.LIKE - 320)) | (1 << (PLpgSQLParser.NATURAL - 320)) | (1 << (PLpgSQLParser.NOTNULL - 320)) | (1 << (PLpgSQLParser.OUTER - 320)) | (1 << (PLpgSQLParser.OVERLAPS - 320)) | (1 << (PLpgSQLParser.RIGHT - 320)) | (1 << (PLpgSQLParser.SIMILAR - 320)) | (1 << (PLpgSQLParser.TABLESAMPLE - 320)) | (1 << (PLpgSQLParser.VERBOSE - 320)) | (1 << (PLpgSQLParser.ALL - 320)) | (1 << (PLpgSQLParser.ANY - 320)) | (1 << (PLpgSQLParser.ARRAY - 320)) | (1 << (PLpgSQLParser.CASE - 320)) | (1 << (PLpgSQLParser.CAST - 320)) | (1 << (PLpgSQLParser.CURRENT_CATALOG - 320)))) != 0) or ((((_la - 384)) & ~0x3f) == 0 and ((1 << (_la - 384)) & ((1 << (PLpgSQLParser.CURRENT_DATE - 384)) | (1 << (PLpgSQLParser.CURRENT_TIME - 384)) | (1 << (PLpgSQLParser.CURRENT_TIMESTAMP - 384)) | (1 << (PLpgSQLParser.CURRENT_USER - 384)) | (1 << (PLpgSQLParser.FALSE - 384)) | (1 << (PLpgSQLParser.LOCALTIME - 384)) | (1 << (PLpgSQLParser.LOCALTIMESTAMP - 384)) | (1 << (PLpgSQLParser.NOT - 384)) | (1 << (PLpgSQLParser.NULL - 384)) | (1 << (PLpgSQLParser.ON - 384)) | (1 << (PLpgSQLParser.SESSION_USER - 384)) | (1 << (PLpgSQLParser.SOME - 384)) | (1 << (PLpgSQLParser.TRUE - 384)) | (1 << (PLpgSQLParser.USER - 384)) | (1 << (PLpgSQLParser.ALIGNMENT - 384)) | (1 << (PLpgSQLParser.BASETYPE - 384)) | (1 << (PLpgSQLParser.BUFFERS - 384)) | (1 << (PLpgSQLParser.BYPASSRLS - 384)) | (1 << (PLpgSQLParser.CANONICAL - 384)))) != 0) or ((((_la - 448)) & ~0x3f) == 0 and ((1 << (_la - 448)) & ((1 << (PLpgSQLParser.CATEGORY - 448)) | (1 << (PLpgSQLParser.COLLATABLE - 448)) | (1 << (PLpgSQLParser.COMBINEFUNC - 448)) | (1 << (PLpgSQLParser.COMMUTATOR - 448)) | (1 << (PLpgSQLParser.CONNECT - 448)) | (1 << (PLpgSQLParser.COSTS - 448)) | (1 << (PLpgSQLParser.CREATEDB - 448)) | (1 << (PLpgSQLParser.CREATEROLE - 448)) | (1 << (PLpgSQLParser.DESERIALFUNC - 448)) | (1 << (PLpgSQLParser.DETERMINISTIC - 448)) | (1 << (PLpgSQLParser.DISABLE_PAGE_SKIPPING - 448)) | (1 << (PLpgSQLParser.ELEMENT - 448)) | (1 << (PLpgSQLParser.EXTENDED - 448)) | (1 << (PLpgSQLParser.FINALFUNC - 448)) | (1 << (PLpgSQLParser.FINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.FINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.FORCE_NOT_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_NULL - 448)) | (1 << (PLpgSQLParser.FORCE_QUOTE - 448)) | (1 << (PLpgSQLParser.FORMAT - 448)) | (1 << (PLpgSQLParser.GETTOKEN - 448)) | (1 << (PLpgSQLParser.HASH - 448)) | (1 << (PLpgSQLParser.HASHES - 448)) | (1 << (PLpgSQLParser.HEADLINE - 448)) | (1 << (PLpgSQLParser.HYPOTHETICAL - 448)) | (1 << (PLpgSQLParser.INDEX_CLEANUP - 448)) | (1 << (PLpgSQLParser.INIT - 448)) | (1 << (PLpgSQLParser.INITCOND - 448)) | (1 << (PLpgSQLParser.INTERNALLENGTH - 448)) | (1 << (PLpgSQLParser.JSON - 448)) | (1 << (PLpgSQLParser.LC_COLLATE - 448)) | (1 << (PLpgSQLParser.LC_CTYPE - 448)) | (1 << (PLpgSQLParser.LEFTARG - 448)) | (1 << (PLpgSQLParser.LEXIZE - 448)) | (1 << (PLpgSQLParser.LEXTYPES - 448)) | (1 << (PLpgSQLParser.LIST - 448)) | (1 << (PLpgSQLParser.LOCALE - 448)) | (1 << (PLpgSQLParser.LOGIN - 448)) | (1 << (PLpgSQLParser.MAIN - 448)) | (1 << (PLpgSQLParser.MERGES - 448)) | (1 << (PLpgSQLParser.MFINALFUNC - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_EXTRA - 448)) | (1 << (PLpgSQLParser.MFINALFUNC_MODIFY - 448)) | (1 << (PLpgSQLParser.MINITCOND - 448)) | (1 << (PLpgSQLParser.MINVFUNC - 448)) | (1 << (PLpgSQLParser.MODULUS - 448)) | (1 << (PLpgSQLParser.MSFUNC - 448)) | (1 << (PLpgSQLParser.MSSPACE - 448)) | (1 << (PLpgSQLParser.MSTYPE - 448)) | (1 << (PLpgSQLParser.NEGATOR - 448)) | (1 << (PLpgSQLParser.NOBYPASSRLS - 448)) | (1 << (PLpgSQLParser.NOCREATEDB - 448)) | (1 << (PLpgSQLParser.NOCREATEROLE - 448)) | (1 << (PLpgSQLParser.NOINHERIT - 448)) | (1 << (PLpgSQLParser.NOLOGIN - 448)) | (1 << (PLpgSQLParser.NOREPLICATION - 448)) | (1 << (PLpgSQLParser.NOSUPERUSER - 448)) | (1 << (PLpgSQLParser.OUTPUT - 448)) | (1 << (PLpgSQLParser.PASSEDBYVALUE - 448)) | (1 << (PLpgSQLParser.PATH - 448)) | (1 << (PLpgSQLParser.PERMISSIVE - 448)) | (1 << (PLpgSQLParser.PLAIN - 448)) | (1 << (PLpgSQLParser.PREFERRED - 448)) | (1 << (PLpgSQLParser.PROVIDER - 448)))) != 0) or ((((_la - 512)) & ~0x3f) == 0 and ((1 << (_la - 512)) & ((1 << (PLpgSQLParser.READ_ONLY - 512)) | (1 << (PLpgSQLParser.READ_WRITE - 512)) | (1 << (PLpgSQLParser.RECEIVE - 512)) | (1 << (PLpgSQLParser.REMAINDER - 512)) | (1 << (PLpgSQLParser.REPLICATION - 512)) | (1 << (PLpgSQLParser.RESTRICTED - 512)) | (1 << (PLpgSQLParser.RESTRICTIVE - 512)) | (1 << (PLpgSQLParser.RIGHTARG - 512)) | (1 << (PLpgSQLParser.SAFE - 512)) | (1 << (PLpgSQLParser.SEND - 512)) | (1 << (PLpgSQLParser.SERIALFUNC - 512)) | (1 << (PLpgSQLParser.SETTINGS - 512)) | (1 << (PLpgSQLParser.SFUNC - 512)) | (1 << (PLpgSQLParser.SHAREABLE - 512)) | (1 << (PLpgSQLParser.SKIP_LOCKED - 512)) | (1 << (PLpgSQLParser.SORTOP - 512)) | (1 << (PLpgSQLParser.SSPACE - 512)) | (1 << (PLpgSQLParser.STYPE - 512)) | (1 << (PLpgSQLParser.SUBTYPE_DIFF - 512)) | (1 << (PLpgSQLParser.SUBTYPE_OPCLASS - 512)) | (1 << (PLpgSQLParser.SUBTYPE - 512)) | (1 << (PLpgSQLParser.SUMMARY - 512)) | (1 << (PLpgSQLParser.SUPERUSER - 512)) | (1 << (PLpgSQLParser.TIMING - 512)) | (1 << (PLpgSQLParser.TYPMOD_IN - 512)) | (1 << (PLpgSQLParser.TYPMOD_OUT - 512)) | (1 << (PLpgSQLParser.UNSAFE - 512)) | (1 << (PLpgSQLParser.USAGE - 512)) | (1 << (PLpgSQLParser.VARIABLE - 512)) | (1 << (PLpgSQLParser.YAML - 512)) | (1 << (PLpgSQLParser.ALIAS - 512)) | (1 << (PLpgSQLParser.ASSERT - 512)) | (1 << (PLpgSQLParser.CONSTANT - 512)) | (1 << (PLpgSQLParser.DATATYPE - 512)) | (1 << (PLpgSQLParser.DEBUG - 512)) | (1 << (PLpgSQLParser.DETAIL - 512)) | (1 << (PLpgSQLParser.DIAGNOSTICS - 512)) | (1 << (PLpgSQLParser.ELSEIF - 512)) | (1 << (PLpgSQLParser.ELSIF - 512)) | (1 << (PLpgSQLParser.ERRCODE - 512)) | (1 << (PLpgSQLParser.EXIT - 512)) | (1 << (PLpgSQLParser.EXCEPTION - 512)) | (1 << (PLpgSQLParser.FOREACH - 512)) | (1 << (PLpgSQLParser.GET - 512)) | (1 << (PLpgSQLParser.HINT - 512)) | (1 << (PLpgSQLParser.INFO - 512)) | (1 << (PLpgSQLParser.LOG - 512)) | (1 << (PLpgSQLParser.LOOP - 512)) | (1 << (PLpgSQLParser.MESSAGE - 512)) | (1 << (PLpgSQLParser.NOTICE - 512)) | (1 << (PLpgSQLParser.OPEN - 512)) | (1 << (PLpgSQLParser.PERFORM - 512)) | (1 << (PLpgSQLParser.QUERY - 512)) | (1 << (PLpgSQLParser.RAISE - 512)) | (1 << (PLpgSQLParser.RECORD - 512)) | (1 << (PLpgSQLParser.RETURN - 512)) | (1 << (PLpgSQLParser.REVERSE - 512)) | (1 << (PLpgSQLParser.ROWTYPE - 512)) | (1 << (PLpgSQLParser.SLICE - 512)) | (1 << (PLpgSQLParser.SQLSTATE - 512)) | (1 << (PLpgSQLParser.STACKED - 512)) | (1 << (PLpgSQLParser.WARNING - 512)) | (1 << (PLpgSQLParser.WHILE - 512)))) != 0) or ((((_la - 585)) & ~0x3f) == 0 and ((1 << (_la - 585)) & ((1 << (PLpgSQLParser.LEFT_PAREN - 585)) | (1 << (PLpgSQLParser.PLUS - 585)) | (1 << (PLpgSQLParser.MINUS - 585)) | (1 << (PLpgSQLParser.MULTIPLY - 585)) | (1 << (PLpgSQLParser.LESS_LESS - 585)) | (1 << (PLpgSQLParser.GREATER_GREATER - 585)) | (1 << (PLpgSQLParser.HASH_SIGN - 585)) | (1 << (PLpgSQLParser.OP_CHARS - 585)) | (1 << (PLpgSQLParser.NUMBER_LITERAL - 585)) | (1 << (PLpgSQLParser.REAL_NUMBER - 585)) | (1 << (PLpgSQLParser.DOLLAR_NUMBER - 585)) | (1 << (PLpgSQLParser.Identifier - 585)) | (1 << (PLpgSQLParser.QuotedIdentifier - 585)) | (1 << (PLpgSQLParser.Character_String_Literal - 585)) | (1 << (PLpgSQLParser.BeginDollarStringConstant - 585)))) != 0): + self.state = 7606 + self.vex(0) + + + self.state = 7621 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 7609 + self.match(PLpgSQLParser.WHEN) + self.state = 7610 + self.vex(0) + self.state = 7615 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==PLpgSQLParser.COMMA: + self.state = 7611 + self.match(PLpgSQLParser.COMMA) + self.state = 7612 + self.vex(0) + self.state = 7617 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 7618 + self.match(PLpgSQLParser.THEN) + self.state = 7619 + self.function_statements() + self.state = 7623 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==PLpgSQLParser.WHEN): + break + + self.state = 7627 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==PLpgSQLParser.ELSE: + self.state = 7625 + self.match(PLpgSQLParser.ELSE) + self.state = 7626 + self.function_statements() + + + self.state = 7629 + self.match(PLpgSQLParser.END) + self.state = 7630 + self.match(PLpgSQLParser.CASE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Plpgsql_queryContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def data_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Data_statementContext,0) + + + def execute_stmt(self): + return self.getTypedRuleContext(PLpgSQLParser.Execute_stmtContext,0) + + + def show_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Show_statementContext,0) + + + def explain_statement(self): + return self.getTypedRuleContext(PLpgSQLParser.Explain_statementContext,0) + + + def getRuleIndex(self): + return PLpgSQLParser.RULE_plpgsql_query + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPlpgsql_query" ): + listener.enterPlpgsql_query(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPlpgsql_query" ): + listener.exitPlpgsql_query(self) + + + + + def plpgsql_query(self): + + localctx = PLpgSQLParser.Plpgsql_queryContext(self, self._ctx, self.state) + self.enterRule(localctx, 758, self.RULE_plpgsql_query) + try: + self.state = 7636 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [PLpgSQLParser.DELETE, PLpgSQLParser.INSERT, PLpgSQLParser.UPDATE, PLpgSQLParser.VALUES, PLpgSQLParser.SELECT, PLpgSQLParser.TABLE, PLpgSQLParser.WITH, PLpgSQLParser.LEFT_PAREN]: + self.enterOuterAlt(localctx, 1) + self.state = 7632 + self.data_statement() + pass + elif token in [PLpgSQLParser.EXECUTE]: + self.enterOuterAlt(localctx, 2) + self.state = 7633 + self.execute_stmt() + pass + elif token in [PLpgSQLParser.SHOW]: + self.enterOuterAlt(localctx, 3) + self.state = 7634 + self.show_statement() + pass + elif token in [PLpgSQLParser.EXPLAIN]: + self.enterOuterAlt(localctx, 4) + self.state = 7635 + self.explain_statement() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): + if self._predicates == None: + self._predicates = dict() + self._predicates[279] = self.vex_sempred + self._predicates[280] = self.vex_b_sempred + self._predicates[316] = self.select_ops_sempred + self._predicates[322] = self.from_item_sempred + pred = self._predicates.get(ruleIndex, None) + if pred is None: + raise Exception("No predicate with index:" + str(ruleIndex)) + else: + return pred(localctx, predIndex) + + def vex_sempred(self, localctx:VexContext, predIndex:int): + if predIndex == 0: + return self.precpred(self._ctx, 23) + + + if predIndex == 1: + return self.precpred(self._ctx, 22) + + + if predIndex == 2: + return self.precpred(self._ctx, 21) + + + if predIndex == 3: + return self.precpred(self._ctx, 20) + + + if predIndex == 4: + return self.precpred(self._ctx, 19) + + + if predIndex == 5: + return self.precpred(self._ctx, 15) + + + if predIndex == 6: + return self.precpred(self._ctx, 14) + + + if predIndex == 7: + return self.precpred(self._ctx, 13) + + + if predIndex == 8: + return self.precpred(self._ctx, 12) + + + if predIndex == 9: + return self.precpred(self._ctx, 10) + + + if predIndex == 10: + return self.precpred(self._ctx, 3) + + + if predIndex == 11: + return self.precpred(self._ctx, 2) + + + if predIndex == 12: + return self.precpred(self._ctx, 28) + + + if predIndex == 13: + return self.precpred(self._ctx, 25) + + + if predIndex == 14: + return self.precpred(self._ctx, 17) + + + if predIndex == 15: + return self.precpred(self._ctx, 16) + + + if predIndex == 16: + return self.precpred(self._ctx, 11) + + + if predIndex == 17: + return self.precpred(self._ctx, 9) + + + if predIndex == 18: + return self.precpred(self._ctx, 8) + + + if predIndex == 19: + return self.precpred(self._ctx, 7) + + + if predIndex == 20: + return self.precpred(self._ctx, 6) + + + if predIndex == 21: + return self.precpred(self._ctx, 5) + + + def vex_b_sempred(self, localctx:Vex_bContext, predIndex:int): + if predIndex == 22: + return self.precpred(self._ctx, 12) + + + if predIndex == 23: + return self.precpred(self._ctx, 11) + + + if predIndex == 24: + return self.precpred(self._ctx, 10) + + + if predIndex == 25: + return self.precpred(self._ctx, 9) + + + if predIndex == 26: + return self.precpred(self._ctx, 6) + + + if predIndex == 27: + return self.precpred(self._ctx, 5) + + + if predIndex == 28: + return self.precpred(self._ctx, 16) + + + if predIndex == 29: + return self.precpred(self._ctx, 7) + + + if predIndex == 30: + return self.precpred(self._ctx, 4) + + + if predIndex == 31: + return self.precpred(self._ctx, 3) + + + if predIndex == 32: + return self.precpred(self._ctx, 2) + + + def select_ops_sempred(self, localctx:Select_opsContext, predIndex:int): + if predIndex == 33: + return self.precpred(self._ctx, 2) + + + def from_item_sempred(self, localctx:From_itemContext, predIndex:int): + if predIndex == 34: + return self.precpred(self._ctx, 5) + + + if predIndex == 35: + return self.precpred(self._ctx, 2) + + + if predIndex == 36: + return self.precpred(self._ctx, 4) + + + if predIndex == 37: + return self.precpred(self._ctx, 3) + + + + + diff --git a/sql_to_code/parsers/generated/PLpgSQLParser.tokens b/sql_to_code/parsers/generated/PLpgSQLParser.tokens new file mode 100644 index 0000000..c2a813a --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLParser.tokens @@ -0,0 +1,653 @@ +ABORT=1 +ABSOLUTE=2 +ACCESS=3 +ACTION=4 +ADD=5 +ADMIN=6 +AFTER=7 +AGGREGATE=8 +ALSO=9 +ALTER=10 +ALWAYS=11 +ASSERTION=12 +ASSIGNMENT=13 +AT=14 +ATTACH=15 +ATTRIBUTE=16 +BACKWARD=17 +BEFORE=18 +BEGIN=19 +BY=20 +CACHE=21 +CALL=22 +CALLED=23 +CASCADE=24 +CASCADED=25 +CATALOG=26 +CHAIN=27 +CHARACTERISTICS=28 +CHECKPOINT=29 +CLASS=30 +CLOSE=31 +CLUSTER=32 +COLUMNS=33 +COMMENT=34 +COMMENTS=35 +COMMIT=36 +COMMITTED=37 +CONFIGURATION=38 +CONFLICT=39 +CONNECTION=40 +CONSTRAINTS=41 +CONTENT=42 +CONTINUE=43 +CONVERSION=44 +COPY=45 +COST=46 +CSV=47 +CUBE=48 +CURRENT=49 +CURSOR=50 +CYCLE=51 +DATA=52 +DATABASE=53 +DAY=54 +DEALLOCATE=55 +DECLARE=56 +DEFAULTS=57 +DEFERRED=58 +DEFINER=59 +DELETE=60 +DELIMITER=61 +DELIMITERS=62 +DEPENDS=63 +DETACH=64 +DICTIONARY=65 +DISABLE=66 +DISCARD=67 +DOCUMENT=68 +DOMAIN=69 +DOUBLE=70 +DROP=71 +EACH=72 +ENABLE=73 +ENCODING=74 +ENCRYPTED=75 +ENUM=76 +ESCAPE=77 +EVENT=78 +EXCLUDE=79 +EXCLUDING=80 +EXCLUSIVE=81 +EXECUTE=82 +EXPLAIN=83 +EXTENSION=84 +EXTERNAL=85 +FAMILY=86 +FILTER=87 +FIRST=88 +FOLLOWING=89 +FORCE=90 +FORWARD=91 +FUNCTION=92 +FUNCTIONS=93 +GENERATED=94 +GLOBAL=95 +GRANTED=96 +GROUPS=97 +HANDLER=98 +HEADER=99 +HOLD=100 +HOUR=101 +IDENTITY=102 +IF=103 +IMMEDIATE=104 +IMMUTABLE=105 +IMPLICIT=106 +IMPORT=107 +INCLUDE=108 +INCLUDING=109 +INCREMENT=110 +INDEX=111 +INDEXES=112 +INHERIT=113 +INHERITS=114 +INLINE=115 +INPUT=116 +INSENSITIVE=117 +INSERT=118 +INSTEAD=119 +INVOKER=120 +ISOLATION=121 +KEY=122 +LABEL=123 +LANGUAGE=124 +LARGE=125 +LAST=126 +LEAKPROOF=127 +LEVEL=128 +LISTEN=129 +LOAD=130 +LOCAL=131 +LOCATION=132 +LOCK=133 +LOCKED=134 +LOGGED=135 +MAPPING=136 +MATCH=137 +MATERIALIZED=138 +MAXVALUE=139 +METHOD=140 +MINUTE=141 +MINVALUE=142 +MODE=143 +MONTH=144 +MOVE=145 +NAME=146 +NAMES=147 +NEW=148 +NEXT=149 +NO=150 +NOTHING=151 +NOTIFY=152 +NOWAIT=153 +NULLS=154 +OBJECT=155 +OF=156 +OFF=157 +OIDS=158 +OLD=159 +OPERATOR=160 +OPTION=161 +OPTIONS=162 +ORDINALITY=163 +OTHERS=164 +OVER=165 +OVERRIDING=166 +OWNED=167 +OWNER=168 +PARALLEL=169 +PARSER=170 +PARTIAL=171 +PARTITION=172 +PASSING=173 +PASSWORD=174 +PLANS=175 +POLICY=176 +PRECEDING=177 +PREPARE=178 +PREPARED=179 +PRESERVE=180 +PRIOR=181 +PRIVILEGES=182 +PROCEDURAL=183 +PROCEDURE=184 +PROCEDURES=185 +PROGRAM=186 +PUBLICATION=187 +QUOTE=188 +RANGE=189 +READ=190 +REASSIGN=191 +RECHECK=192 +RECURSIVE=193 +REF=194 +REFERENCING=195 +REFRESH=196 +REINDEX=197 +RELATIVE=198 +RELEASE=199 +RENAME=200 +REPEATABLE=201 +REPLACE=202 +REPLICA=203 +RESET=204 +RESTART=205 +RESTRICT=206 +RETURNS=207 +REVOKE=208 +ROLE=209 +ROLLBACK=210 +ROLLUP=211 +ROUTINE=212 +ROUTINES=213 +ROWS=214 +RULE=215 +SAVEPOINT=216 +SCHEMA=217 +SCHEMAS=218 +SCROLL=219 +SEARCH=220 +SECOND=221 +SECURITY=222 +SEQUENCE=223 +SEQUENCES=224 +SERIALIZABLE=225 +SERVER=226 +SESSION=227 +SET=228 +SETS=229 +SHARE=230 +SHOW=231 +SIMPLE=232 +SKIP_=233 +SNAPSHOT=234 +SQL=235 +STABLE=236 +STANDALONE=237 +START=238 +STATEMENT=239 +STATISTICS=240 +STDIN=241 +STDOUT=242 +STORAGE=243 +STORED=244 +STRICT=245 +STRIP=246 +SUBSCRIPTION=247 +SUPPORT=248 +SYSID=249 +SYSTEM=250 +TABLES=251 +TABLESPACE=252 +TEMP=253 +TEMPLATE=254 +TEMPORARY=255 +TEXT=256 +TIES=257 +TRANSACTION=258 +TRANSFORM=259 +TRIGGER=260 +TRUNCATE=261 +TRUSTED=262 +TYPE=263 +TYPES=264 +UNBOUNDED=265 +UNCOMMITTED=266 +UNENCRYPTED=267 +UNKNOWN=268 +UNLISTEN=269 +UNLOGGED=270 +UNTIL=271 +UPDATE=272 +VACUUM=273 +VALID=274 +VALIDATE=275 +VALIDATOR=276 +VALUE=277 +VARYING=278 +VERSION=279 +VIEW=280 +VIEWS=281 +VOLATILE=282 +WHITESPACE=283 +WITHIN=284 +WITHOUT=285 +WORK=286 +WRAPPER=287 +WRITE=288 +XML=289 +YEAR=290 +YES=291 +ZONE=292 +BETWEEN=293 +BIGINT=294 +BIT=295 +BOOLEAN=296 +CHAR=297 +CHARACTER=298 +COALESCE=299 +DEC=300 +DECIMAL=301 +EXISTS=302 +EXTRACT=303 +FLOAT=304 +GREATEST=305 +GROUPING=306 +INOUT=307 +INT=308 +INTEGER=309 +INTERVAL=310 +LEAST=311 +NATIONAL=312 +NCHAR=313 +NONE=314 +NULLIF=315 +NUMERIC=316 +OUT=317 +OVERLAY=318 +POSITION=319 +PRECISION=320 +REAL=321 +ROW=322 +SETOF=323 +SMALLINT=324 +SUBSTRING=325 +TIME=326 +TIMESTAMP=327 +TREAT=328 +TRIM=329 +VALUES=330 +VARCHAR=331 +XMLATTRIBUTES=332 +XMLCONCAT=333 +XMLELEMENT=334 +XMLEXISTS=335 +XMLFOREST=336 +XMLNAMESPACES=337 +XMLPARSE=338 +XMLPI=339 +XMLROOT=340 +XMLSERIALIZE=341 +XMLTABLE=342 +AUTHORIZATION=343 +BINARY=344 +COLLATION=345 +CONCURRENTLY=346 +CROSS=347 +CURRENT_SCHEMA=348 +FREEZE=349 +FULL=350 +ILIKE=351 +INNER=352 +IS=353 +ISNULL=354 +JOIN=355 +LEFT=356 +LIKE=357 +NATURAL=358 +NOTNULL=359 +OUTER=360 +OVERLAPS=361 +RIGHT=362 +SIMILAR=363 +TABLESAMPLE=364 +VERBOSE=365 +ALL=366 +ANALYSE=367 +ANALYZE=368 +AND=369 +ANY=370 +ARRAY=371 +AS=372 +ASC=373 +ASYMMETRIC=374 +BOTH=375 +CASE=376 +CAST=377 +CHECK=378 +COLLATE=379 +COLUMN=380 +CONSTRAINT=381 +CREATE=382 +CURRENT_CATALOG=383 +CURRENT_DATE=384 +CURRENT_ROLE=385 +CURRENT_TIME=386 +CURRENT_TIMESTAMP=387 +CURRENT_USER=388 +DEFAULT=389 +DEFERRABLE=390 +DESC=391 +DISTINCT=392 +DO=393 +ELSE=394 +END=395 +EXCEPT=396 +FALSE=397 +FETCH=398 +FOR=399 +FOREIGN=400 +FROM=401 +GRANT=402 +GROUP=403 +HAVING=404 +IN=405 +INITIALLY=406 +INTERSECT=407 +INTO=408 +LATERAL=409 +LEADING=410 +LIMIT=411 +LOCALTIME=412 +LOCALTIMESTAMP=413 +NOT=414 +NULL=415 +OFFSET=416 +ON=417 +ONLY=418 +OR=419 +ORDER=420 +PLACING=421 +PRIMARY=422 +REFERENCES=423 +RETURNING=424 +SELECT=425 +SESSION_USER=426 +SOME=427 +SYMMETRIC=428 +TABLE=429 +THEN=430 +TO=431 +TRAILING=432 +TRUE=433 +UNION=434 +UNIQUE=435 +USER=436 +USING=437 +VARIADIC=438 +WHEN=439 +WHERE=440 +WINDOW=441 +WITH=442 +ALIGNMENT=443 +BASETYPE=444 +BUFFERS=445 +BYPASSRLS=446 +CANONICAL=447 +CATEGORY=448 +COLLATABLE=449 +COMBINEFUNC=450 +COMMUTATOR=451 +CONNECT=452 +COSTS=453 +CREATEDB=454 +CREATEROLE=455 +DESERIALFUNC=456 +DETERMINISTIC=457 +DISABLE_PAGE_SKIPPING=458 +ELEMENT=459 +EXTENDED=460 +FINALFUNC=461 +FINALFUNC_EXTRA=462 +FINALFUNC_MODIFY=463 +FORCE_NOT_NULL=464 +FORCE_NULL=465 +FORCE_QUOTE=466 +FORMAT=467 +GETTOKEN=468 +HASH=469 +HASHES=470 +HEADLINE=471 +HYPOTHETICAL=472 +INDEX_CLEANUP=473 +INIT=474 +INITCOND=475 +INTERNALLENGTH=476 +JSON=477 +LC_COLLATE=478 +LC_CTYPE=479 +LEFTARG=480 +LEXIZE=481 +LEXTYPES=482 +LIST=483 +LOCALE=484 +LOGIN=485 +MAIN=486 +MERGES=487 +MFINALFUNC=488 +MFINALFUNC_EXTRA=489 +MFINALFUNC_MODIFY=490 +MINITCOND=491 +MINVFUNC=492 +MODULUS=493 +MSFUNC=494 +MSSPACE=495 +MSTYPE=496 +NEGATOR=497 +NOBYPASSRLS=498 +NOCREATEDB=499 +NOCREATEROLE=500 +NOINHERIT=501 +NOLOGIN=502 +NOREPLICATION=503 +NOSUPERUSER=504 +OUTPUT=505 +PASSEDBYVALUE=506 +PATH=507 +PERMISSIVE=508 +PLAIN=509 +PREFERRED=510 +PROVIDER=511 +READ_ONLY=512 +READ_WRITE=513 +RECEIVE=514 +REMAINDER=515 +REPLICATION=516 +RESTRICTED=517 +RESTRICTIVE=518 +RIGHTARG=519 +SAFE=520 +SEND=521 +SERIALFUNC=522 +SETTINGS=523 +SFUNC=524 +SHAREABLE=525 +SKIP_LOCKED=526 +SORTOP=527 +SSPACE=528 +STYPE=529 +SUBTYPE_DIFF=530 +SUBTYPE_OPCLASS=531 +SUBTYPE=532 +SUMMARY=533 +SUPERUSER=534 +TIMING=535 +TYPMOD_IN=536 +TYPMOD_OUT=537 +UNSAFE=538 +USAGE=539 +VARIABLE=540 +YAML=541 +ALIAS=542 +ASSERT=543 +CONSTANT=544 +DATATYPE=545 +DEBUG=546 +DETAIL=547 +DIAGNOSTICS=548 +ELSEIF=549 +ELSIF=550 +ERRCODE=551 +EXIT=552 +EXCEPTION=553 +FOREACH=554 +GET=555 +HINT=556 +INFO=557 +LOG=558 +LOOP=559 +MESSAGE=560 +NOTICE=561 +OPEN=562 +PERFORM=563 +QUERY=564 +RAISE=565 +RECORD=566 +RETURN=567 +REVERSE=568 +ROWTYPE=569 +SLICE=570 +SQLSTATE=571 +STACKED=572 +WARNING=573 +WHILE=574 +CAST_EXPRESSION=575 +EQUAL=576 +COLON=577 +SEMI_COLON=578 +COMMA=579 +NOT_EQUAL=580 +LTH=581 +LEQ=582 +GTH=583 +GEQ=584 +LEFT_PAREN=585 +RIGHT_PAREN=586 +PLUS=587 +MINUS=588 +MULTIPLY=589 +DIVIDE=590 +MODULAR=591 +EXP=592 +DOT=593 +QUOTE_CHAR=594 +DOUBLE_QUOTE=595 +DOLLAR=596 +LEFT_BRACKET=597 +RIGHT_BRACKET=598 +EQUAL_GTH=599 +COLON_EQUAL=600 +LESS_LESS=601 +GREATER_GREATER=602 +DOUBLE_DOT=603 +HASH_SIGN=604 +BlockComment=605 +LineComment=606 +OP_CHARS=607 +NUMBER_LITERAL=608 +REAL_NUMBER=609 +DOLLAR_NUMBER=610 +Identifier=611 +QuotedIdentifier=612 +Character_String_Literal=613 +BeginDollarStringConstant=614 +Space=615 +White_Space=616 +New_Line=617 +Tab=618 +BOM=619 +BAD=620 +Text_between_Dollar=621 +EndDollarStringConstant=622 +'='=576 +':'=577 +';'=578 +','=579 +'<'=581 +'<='=582 +'>'=583 +'>='=584 +'('=585 +')'=586 +'+'=587 +'-'=588 +'*'=589 +'/'=590 +'%'=591 +'^'=592 +'.'=593 +'\''=594 +'"'=595 +'$'=596 +'['=597 +']'=598 +'=>'=599 +':='=600 +'<<'=601 +'>>'=602 +'..'=603 +'#'=604 +' '=615 +'\u0009'=618 +'\ufeff'=619 diff --git a/sql_to_code/parsers/generated/PLpgSQLParserListener.py b/sql_to_code/parsers/generated/PLpgSQLParserListener.py new file mode 100644 index 0000000..590b38a --- /dev/null +++ b/sql_to_code/parsers/generated/PLpgSQLParserListener.py @@ -0,0 +1,3481 @@ +# Generated from PLpgSQLParser.g4 by ANTLR 4.9 +from antlr4 import * + +if __name__ is not None and "." in __name__: + from .PLpgSQLParser import PLpgSQLParser +else: + from PLpgSQLParser import PLpgSQLParser + +# This class defines a complete listener for a parse tree produced by PLpgSQLParser. +class PLpgSQLParserListener(ParseTreeListener): + + # Enter a parse tree produced by PLpgSQLParser#sql. + def enterSql(self, ctx: PLpgSQLParser.SqlContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#sql. + def exitSql(self, ctx: PLpgSQLParser.SqlContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#qname_parser. + def enterQname_parser(self, ctx: PLpgSQLParser.Qname_parserContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#qname_parser. + def exitQname_parser(self, ctx: PLpgSQLParser.Qname_parserContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_args_parser. + def enterFunction_args_parser(self, ctx: PLpgSQLParser.Function_args_parserContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_args_parser. + def exitFunction_args_parser(self, ctx: PLpgSQLParser.Function_args_parserContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#vex_eof. + def enterVex_eof(self, ctx: PLpgSQLParser.Vex_eofContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#vex_eof. + def exitVex_eof(self, ctx: PLpgSQLParser.Vex_eofContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#plpgsql_function. + def enterPlpgsql_function(self, ctx: PLpgSQLParser.Plpgsql_functionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#plpgsql_function. + def exitPlpgsql_function(self, ctx: PLpgSQLParser.Plpgsql_functionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#plpgsql_function_test_list. + def enterPlpgsql_function_test_list( + self, ctx: PLpgSQLParser.Plpgsql_function_test_listContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#plpgsql_function_test_list. + def exitPlpgsql_function_test_list( + self, ctx: PLpgSQLParser.Plpgsql_function_test_listContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#statement. + def enterStatement(self, ctx: PLpgSQLParser.StatementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#statement. + def exitStatement(self, ctx: PLpgSQLParser.StatementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#data_statement. + def enterData_statement(self, ctx: PLpgSQLParser.Data_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#data_statement. + def exitData_statement(self, ctx: PLpgSQLParser.Data_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#script_statement. + def enterScript_statement(self, ctx: PLpgSQLParser.Script_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#script_statement. + def exitScript_statement(self, ctx: PLpgSQLParser.Script_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#script_transaction. + def enterScript_transaction(self, ctx: PLpgSQLParser.Script_transactionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#script_transaction. + def exitScript_transaction(self, ctx: PLpgSQLParser.Script_transactionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#transaction_mode. + def enterTransaction_mode(self, ctx: PLpgSQLParser.Transaction_modeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#transaction_mode. + def exitTransaction_mode(self, ctx: PLpgSQLParser.Transaction_modeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#lock_table. + def enterLock_table(self, ctx: PLpgSQLParser.Lock_tableContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#lock_table. + def exitLock_table(self, ctx: PLpgSQLParser.Lock_tableContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#lock_mode. + def enterLock_mode(self, ctx: PLpgSQLParser.Lock_modeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#lock_mode. + def exitLock_mode(self, ctx: PLpgSQLParser.Lock_modeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#script_additional. + def enterScript_additional(self, ctx: PLpgSQLParser.Script_additionalContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#script_additional. + def exitScript_additional(self, ctx: PLpgSQLParser.Script_additionalContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#additional_statement. + def enterAdditional_statement(self, ctx: PLpgSQLParser.Additional_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#additional_statement. + def exitAdditional_statement(self, ctx: PLpgSQLParser.Additional_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#explain_statement. + def enterExplain_statement(self, ctx: PLpgSQLParser.Explain_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#explain_statement. + def exitExplain_statement(self, ctx: PLpgSQLParser.Explain_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#explain_query. + def enterExplain_query(self, ctx: PLpgSQLParser.Explain_queryContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#explain_query. + def exitExplain_query(self, ctx: PLpgSQLParser.Explain_queryContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#execute_statement. + def enterExecute_statement(self, ctx: PLpgSQLParser.Execute_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#execute_statement. + def exitExecute_statement(self, ctx: PLpgSQLParser.Execute_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#declare_statement. + def enterDeclare_statement(self, ctx: PLpgSQLParser.Declare_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#declare_statement. + def exitDeclare_statement(self, ctx: PLpgSQLParser.Declare_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#show_statement. + def enterShow_statement(self, ctx: PLpgSQLParser.Show_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#show_statement. + def exitShow_statement(self, ctx: PLpgSQLParser.Show_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#explain_option. + def enterExplain_option(self, ctx: PLpgSQLParser.Explain_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#explain_option. + def exitExplain_option(self, ctx: PLpgSQLParser.Explain_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_name. + def enterUser_name(self, ctx: PLpgSQLParser.User_nameContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_name. + def exitUser_name(self, ctx: PLpgSQLParser.User_nameContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_cols_list. + def enterTable_cols_list(self, ctx: PLpgSQLParser.Table_cols_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_cols_list. + def exitTable_cols_list(self, ctx: PLpgSQLParser.Table_cols_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_cols. + def enterTable_cols(self, ctx: PLpgSQLParser.Table_colsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_cols. + def exitTable_cols(self, ctx: PLpgSQLParser.Table_colsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#vacuum_mode. + def enterVacuum_mode(self, ctx: PLpgSQLParser.Vacuum_modeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#vacuum_mode. + def exitVacuum_mode(self, ctx: PLpgSQLParser.Vacuum_modeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#vacuum_option. + def enterVacuum_option(self, ctx: PLpgSQLParser.Vacuum_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#vacuum_option. + def exitVacuum_option(self, ctx: PLpgSQLParser.Vacuum_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#analyze_mode. + def enterAnalyze_mode(self, ctx: PLpgSQLParser.Analyze_modeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#analyze_mode. + def exitAnalyze_mode(self, ctx: PLpgSQLParser.Analyze_modeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#boolean_value. + def enterBoolean_value(self, ctx: PLpgSQLParser.Boolean_valueContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#boolean_value. + def exitBoolean_value(self, ctx: PLpgSQLParser.Boolean_valueContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#fetch_move_direction. + def enterFetch_move_direction(self, ctx: PLpgSQLParser.Fetch_move_directionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#fetch_move_direction. + def exitFetch_move_direction(self, ctx: PLpgSQLParser.Fetch_move_directionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_statement. + def enterSchema_statement(self, ctx: PLpgSQLParser.Schema_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_statement. + def exitSchema_statement(self, ctx: PLpgSQLParser.Schema_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_create. + def enterSchema_create(self, ctx: PLpgSQLParser.Schema_createContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_create. + def exitSchema_create(self, ctx: PLpgSQLParser.Schema_createContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_alter. + def enterSchema_alter(self, ctx: PLpgSQLParser.Schema_alterContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_alter. + def exitSchema_alter(self, ctx: PLpgSQLParser.Schema_alterContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_drop. + def enterSchema_drop(self, ctx: PLpgSQLParser.Schema_dropContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_drop. + def exitSchema_drop(self, ctx: PLpgSQLParser.Schema_dropContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_import. + def enterSchema_import(self, ctx: PLpgSQLParser.Schema_importContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_import. + def exitSchema_import(self, ctx: PLpgSQLParser.Schema_importContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_function_statement. + def enterAlter_function_statement( + self, ctx: PLpgSQLParser.Alter_function_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_function_statement. + def exitAlter_function_statement( + self, ctx: PLpgSQLParser.Alter_function_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_aggregate_statement. + def enterAlter_aggregate_statement( + self, ctx: PLpgSQLParser.Alter_aggregate_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_aggregate_statement. + def exitAlter_aggregate_statement( + self, ctx: PLpgSQLParser.Alter_aggregate_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_extension_statement. + def enterAlter_extension_statement( + self, ctx: PLpgSQLParser.Alter_extension_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_extension_statement. + def exitAlter_extension_statement( + self, ctx: PLpgSQLParser.Alter_extension_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_extension_action. + def enterAlter_extension_action( + self, ctx: PLpgSQLParser.Alter_extension_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_extension_action. + def exitAlter_extension_action( + self, ctx: PLpgSQLParser.Alter_extension_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#extension_member_object. + def enterExtension_member_object( + self, ctx: PLpgSQLParser.Extension_member_objectContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#extension_member_object. + def exitExtension_member_object( + self, ctx: PLpgSQLParser.Extension_member_objectContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_schema_statement. + def enterAlter_schema_statement( + self, ctx: PLpgSQLParser.Alter_schema_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_schema_statement. + def exitAlter_schema_statement( + self, ctx: PLpgSQLParser.Alter_schema_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_language_statement. + def enterAlter_language_statement( + self, ctx: PLpgSQLParser.Alter_language_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_language_statement. + def exitAlter_language_statement( + self, ctx: PLpgSQLParser.Alter_language_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_table_statement. + def enterAlter_table_statement( + self, ctx: PLpgSQLParser.Alter_table_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_table_statement. + def exitAlter_table_statement( + self, ctx: PLpgSQLParser.Alter_table_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_action. + def enterTable_action(self, ctx: PLpgSQLParser.Table_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_action. + def exitTable_action(self, ctx: PLpgSQLParser.Table_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#column_action. + def enterColumn_action(self, ctx: PLpgSQLParser.Column_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#column_action. + def exitColumn_action(self, ctx: PLpgSQLParser.Column_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#identity_body. + def enterIdentity_body(self, ctx: PLpgSQLParser.Identity_bodyContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#identity_body. + def exitIdentity_body(self, ctx: PLpgSQLParser.Identity_bodyContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_identity. + def enterAlter_identity(self, ctx: PLpgSQLParser.Alter_identityContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_identity. + def exitAlter_identity(self, ctx: PLpgSQLParser.Alter_identityContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#storage_option. + def enterStorage_option(self, ctx: PLpgSQLParser.Storage_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#storage_option. + def exitStorage_option(self, ctx: PLpgSQLParser.Storage_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#validate_constraint. + def enterValidate_constraint(self, ctx: PLpgSQLParser.Validate_constraintContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#validate_constraint. + def exitValidate_constraint(self, ctx: PLpgSQLParser.Validate_constraintContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_constraint. + def enterDrop_constraint(self, ctx: PLpgSQLParser.Drop_constraintContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_constraint. + def exitDrop_constraint(self, ctx: PLpgSQLParser.Drop_constraintContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_deferrable. + def enterTable_deferrable(self, ctx: PLpgSQLParser.Table_deferrableContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_deferrable. + def exitTable_deferrable(self, ctx: PLpgSQLParser.Table_deferrableContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_initialy_immed. + def enterTable_initialy_immed(self, ctx: PLpgSQLParser.Table_initialy_immedContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_initialy_immed. + def exitTable_initialy_immed(self, ctx: PLpgSQLParser.Table_initialy_immedContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_actions_common. + def enterFunction_actions_common( + self, ctx: PLpgSQLParser.Function_actions_commonContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_actions_common. + def exitFunction_actions_common( + self, ctx: PLpgSQLParser.Function_actions_commonContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_def. + def enterFunction_def(self, ctx: PLpgSQLParser.Function_defContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_def. + def exitFunction_def(self, ctx: PLpgSQLParser.Function_defContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_index_statement. + def enterAlter_index_statement( + self, ctx: PLpgSQLParser.Alter_index_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_index_statement. + def exitAlter_index_statement( + self, ctx: PLpgSQLParser.Alter_index_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#index_def_action. + def enterIndex_def_action(self, ctx: PLpgSQLParser.Index_def_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#index_def_action. + def exitIndex_def_action(self, ctx: PLpgSQLParser.Index_def_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_default_privileges. + def enterAlter_default_privileges( + self, ctx: PLpgSQLParser.Alter_default_privilegesContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_default_privileges. + def exitAlter_default_privileges( + self, ctx: PLpgSQLParser.Alter_default_privilegesContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#abbreviated_grant_or_revoke. + def enterAbbreviated_grant_or_revoke( + self, ctx: PLpgSQLParser.Abbreviated_grant_or_revokeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#abbreviated_grant_or_revoke. + def exitAbbreviated_grant_or_revoke( + self, ctx: PLpgSQLParser.Abbreviated_grant_or_revokeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#grant_option_for. + def enterGrant_option_for(self, ctx: PLpgSQLParser.Grant_option_forContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#grant_option_for. + def exitGrant_option_for(self, ctx: PLpgSQLParser.Grant_option_forContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_sequence_statement. + def enterAlter_sequence_statement( + self, ctx: PLpgSQLParser.Alter_sequence_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_sequence_statement. + def exitAlter_sequence_statement( + self, ctx: PLpgSQLParser.Alter_sequence_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_view_statement. + def enterAlter_view_statement(self, ctx: PLpgSQLParser.Alter_view_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_view_statement. + def exitAlter_view_statement(self, ctx: PLpgSQLParser.Alter_view_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_event_trigger. + def enterAlter_event_trigger(self, ctx: PLpgSQLParser.Alter_event_triggerContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_event_trigger. + def exitAlter_event_trigger(self, ctx: PLpgSQLParser.Alter_event_triggerContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_event_trigger_action. + def enterAlter_event_trigger_action( + self, ctx: PLpgSQLParser.Alter_event_trigger_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_event_trigger_action. + def exitAlter_event_trigger_action( + self, ctx: PLpgSQLParser.Alter_event_trigger_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_type_statement. + def enterAlter_type_statement(self, ctx: PLpgSQLParser.Alter_type_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_type_statement. + def exitAlter_type_statement(self, ctx: PLpgSQLParser.Alter_type_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_domain_statement. + def enterAlter_domain_statement( + self, ctx: PLpgSQLParser.Alter_domain_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_domain_statement. + def exitAlter_domain_statement( + self, ctx: PLpgSQLParser.Alter_domain_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_server_statement. + def enterAlter_server_statement( + self, ctx: PLpgSQLParser.Alter_server_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_server_statement. + def exitAlter_server_statement( + self, ctx: PLpgSQLParser.Alter_server_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_server_action. + def enterAlter_server_action(self, ctx: PLpgSQLParser.Alter_server_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_server_action. + def exitAlter_server_action(self, ctx: PLpgSQLParser.Alter_server_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_fts_statement. + def enterAlter_fts_statement(self, ctx: PLpgSQLParser.Alter_fts_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_fts_statement. + def exitAlter_fts_statement(self, ctx: PLpgSQLParser.Alter_fts_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_fts_configuration. + def enterAlter_fts_configuration( + self, ctx: PLpgSQLParser.Alter_fts_configurationContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_fts_configuration. + def exitAlter_fts_configuration( + self, ctx: PLpgSQLParser.Alter_fts_configurationContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#type_action. + def enterType_action(self, ctx: PLpgSQLParser.Type_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#type_action. + def exitType_action(self, ctx: PLpgSQLParser.Type_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#set_def_column. + def enterSet_def_column(self, ctx: PLpgSQLParser.Set_def_columnContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#set_def_column. + def exitSet_def_column(self, ctx: PLpgSQLParser.Set_def_columnContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_def. + def enterDrop_def(self, ctx: PLpgSQLParser.Drop_defContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_def. + def exitDrop_def(self, ctx: PLpgSQLParser.Drop_defContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_index_statement. + def enterCreate_index_statement( + self, ctx: PLpgSQLParser.Create_index_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_index_statement. + def exitCreate_index_statement( + self, ctx: PLpgSQLParser.Create_index_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#index_rest. + def enterIndex_rest(self, ctx: PLpgSQLParser.Index_restContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#index_rest. + def exitIndex_rest(self, ctx: PLpgSQLParser.Index_restContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#index_sort. + def enterIndex_sort(self, ctx: PLpgSQLParser.Index_sortContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#index_sort. + def exitIndex_sort(self, ctx: PLpgSQLParser.Index_sortContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#including_index. + def enterIncluding_index(self, ctx: PLpgSQLParser.Including_indexContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#including_index. + def exitIncluding_index(self, ctx: PLpgSQLParser.Including_indexContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#index_where. + def enterIndex_where(self, ctx: PLpgSQLParser.Index_whereContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#index_where. + def exitIndex_where(self, ctx: PLpgSQLParser.Index_whereContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_extension_statement. + def enterCreate_extension_statement( + self, ctx: PLpgSQLParser.Create_extension_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_extension_statement. + def exitCreate_extension_statement( + self, ctx: PLpgSQLParser.Create_extension_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_language_statement. + def enterCreate_language_statement( + self, ctx: PLpgSQLParser.Create_language_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_language_statement. + def exitCreate_language_statement( + self, ctx: PLpgSQLParser.Create_language_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_event_trigger. + def enterCreate_event_trigger(self, ctx: PLpgSQLParser.Create_event_triggerContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_event_trigger. + def exitCreate_event_trigger(self, ctx: PLpgSQLParser.Create_event_triggerContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_type_statement. + def enterCreate_type_statement( + self, ctx: PLpgSQLParser.Create_type_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_type_statement. + def exitCreate_type_statement( + self, ctx: PLpgSQLParser.Create_type_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_domain_statement. + def enterCreate_domain_statement( + self, ctx: PLpgSQLParser.Create_domain_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_domain_statement. + def exitCreate_domain_statement( + self, ctx: PLpgSQLParser.Create_domain_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_server_statement. + def enterCreate_server_statement( + self, ctx: PLpgSQLParser.Create_server_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_server_statement. + def exitCreate_server_statement( + self, ctx: PLpgSQLParser.Create_server_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_fts_dictionary. + def enterCreate_fts_dictionary( + self, ctx: PLpgSQLParser.Create_fts_dictionaryContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_fts_dictionary. + def exitCreate_fts_dictionary( + self, ctx: PLpgSQLParser.Create_fts_dictionaryContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#option_with_value. + def enterOption_with_value(self, ctx: PLpgSQLParser.Option_with_valueContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#option_with_value. + def exitOption_with_value(self, ctx: PLpgSQLParser.Option_with_valueContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_fts_configuration. + def enterCreate_fts_configuration( + self, ctx: PLpgSQLParser.Create_fts_configurationContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_fts_configuration. + def exitCreate_fts_configuration( + self, ctx: PLpgSQLParser.Create_fts_configurationContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_fts_template. + def enterCreate_fts_template(self, ctx: PLpgSQLParser.Create_fts_templateContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_fts_template. + def exitCreate_fts_template(self, ctx: PLpgSQLParser.Create_fts_templateContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_fts_parser. + def enterCreate_fts_parser(self, ctx: PLpgSQLParser.Create_fts_parserContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_fts_parser. + def exitCreate_fts_parser(self, ctx: PLpgSQLParser.Create_fts_parserContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_collation. + def enterCreate_collation(self, ctx: PLpgSQLParser.Create_collationContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_collation. + def exitCreate_collation(self, ctx: PLpgSQLParser.Create_collationContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_collation. + def enterAlter_collation(self, ctx: PLpgSQLParser.Alter_collationContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_collation. + def exitAlter_collation(self, ctx: PLpgSQLParser.Alter_collationContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#collation_option. + def enterCollation_option(self, ctx: PLpgSQLParser.Collation_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#collation_option. + def exitCollation_option(self, ctx: PLpgSQLParser.Collation_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_user_mapping. + def enterCreate_user_mapping(self, ctx: PLpgSQLParser.Create_user_mappingContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_user_mapping. + def exitCreate_user_mapping(self, ctx: PLpgSQLParser.Create_user_mappingContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_user_mapping. + def enterAlter_user_mapping(self, ctx: PLpgSQLParser.Alter_user_mappingContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_user_mapping. + def exitAlter_user_mapping(self, ctx: PLpgSQLParser.Alter_user_mappingContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_user_or_role. + def enterAlter_user_or_role(self, ctx: PLpgSQLParser.Alter_user_or_roleContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_user_or_role. + def exitAlter_user_or_role(self, ctx: PLpgSQLParser.Alter_user_or_roleContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_user_or_role_set_reset. + def enterAlter_user_or_role_set_reset( + self, ctx: PLpgSQLParser.Alter_user_or_role_set_resetContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_user_or_role_set_reset. + def exitAlter_user_or_role_set_reset( + self, ctx: PLpgSQLParser.Alter_user_or_role_set_resetContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_or_role_set_reset. + def enterUser_or_role_set_reset( + self, ctx: PLpgSQLParser.User_or_role_set_resetContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_or_role_set_reset. + def exitUser_or_role_set_reset( + self, ctx: PLpgSQLParser.User_or_role_set_resetContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_group. + def enterAlter_group(self, ctx: PLpgSQLParser.Alter_groupContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_group. + def exitAlter_group(self, ctx: PLpgSQLParser.Alter_groupContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_group_action. + def enterAlter_group_action(self, ctx: PLpgSQLParser.Alter_group_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_group_action. + def exitAlter_group_action(self, ctx: PLpgSQLParser.Alter_group_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_tablespace. + def enterAlter_tablespace(self, ctx: PLpgSQLParser.Alter_tablespaceContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_tablespace. + def exitAlter_tablespace(self, ctx: PLpgSQLParser.Alter_tablespaceContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_owner. + def enterAlter_owner(self, ctx: PLpgSQLParser.Alter_ownerContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_owner. + def exitAlter_owner(self, ctx: PLpgSQLParser.Alter_ownerContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_tablespace_action. + def enterAlter_tablespace_action( + self, ctx: PLpgSQLParser.Alter_tablespace_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_tablespace_action. + def exitAlter_tablespace_action( + self, ctx: PLpgSQLParser.Alter_tablespace_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_statistics. + def enterAlter_statistics(self, ctx: PLpgSQLParser.Alter_statisticsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_statistics. + def exitAlter_statistics(self, ctx: PLpgSQLParser.Alter_statisticsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_foreign_data_wrapper. + def enterAlter_foreign_data_wrapper( + self, ctx: PLpgSQLParser.Alter_foreign_data_wrapperContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_foreign_data_wrapper. + def exitAlter_foreign_data_wrapper( + self, ctx: PLpgSQLParser.Alter_foreign_data_wrapperContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_foreign_data_wrapper_action. + def enterAlter_foreign_data_wrapper_action( + self, ctx: PLpgSQLParser.Alter_foreign_data_wrapper_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_foreign_data_wrapper_action. + def exitAlter_foreign_data_wrapper_action( + self, ctx: PLpgSQLParser.Alter_foreign_data_wrapper_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_operator_statement. + def enterAlter_operator_statement( + self, ctx: PLpgSQLParser.Alter_operator_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_operator_statement. + def exitAlter_operator_statement( + self, ctx: PLpgSQLParser.Alter_operator_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_operator_action. + def enterAlter_operator_action( + self, ctx: PLpgSQLParser.Alter_operator_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_operator_action. + def exitAlter_operator_action( + self, ctx: PLpgSQLParser.Alter_operator_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#operator_set_restrict_join. + def enterOperator_set_restrict_join( + self, ctx: PLpgSQLParser.Operator_set_restrict_joinContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#operator_set_restrict_join. + def exitOperator_set_restrict_join( + self, ctx: PLpgSQLParser.Operator_set_restrict_joinContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_user_mapping. + def enterDrop_user_mapping(self, ctx: PLpgSQLParser.Drop_user_mappingContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_user_mapping. + def exitDrop_user_mapping(self, ctx: PLpgSQLParser.Drop_user_mappingContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_owned. + def enterDrop_owned(self, ctx: PLpgSQLParser.Drop_ownedContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_owned. + def exitDrop_owned(self, ctx: PLpgSQLParser.Drop_ownedContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_operator_statement. + def enterDrop_operator_statement( + self, ctx: PLpgSQLParser.Drop_operator_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_operator_statement. + def exitDrop_operator_statement( + self, ctx: PLpgSQLParser.Drop_operator_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#target_operator. + def enterTarget_operator(self, ctx: PLpgSQLParser.Target_operatorContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#target_operator. + def exitTarget_operator(self, ctx: PLpgSQLParser.Target_operatorContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#domain_constraint. + def enterDomain_constraint(self, ctx: PLpgSQLParser.Domain_constraintContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#domain_constraint. + def exitDomain_constraint(self, ctx: PLpgSQLParser.Domain_constraintContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_transform_statement. + def enterCreate_transform_statement( + self, ctx: PLpgSQLParser.Create_transform_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_transform_statement. + def exitCreate_transform_statement( + self, ctx: PLpgSQLParser.Create_transform_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_access_method. + def enterCreate_access_method(self, ctx: PLpgSQLParser.Create_access_methodContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_access_method. + def exitCreate_access_method(self, ctx: PLpgSQLParser.Create_access_methodContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_user_or_role. + def enterCreate_user_or_role(self, ctx: PLpgSQLParser.Create_user_or_roleContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_user_or_role. + def exitCreate_user_or_role(self, ctx: PLpgSQLParser.Create_user_or_roleContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_or_role_option. + def enterUser_or_role_option(self, ctx: PLpgSQLParser.User_or_role_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_or_role_option. + def exitUser_or_role_option(self, ctx: PLpgSQLParser.User_or_role_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_or_role_option_for_alter. + def enterUser_or_role_option_for_alter( + self, ctx: PLpgSQLParser.User_or_role_option_for_alterContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_or_role_option_for_alter. + def exitUser_or_role_option_for_alter( + self, ctx: PLpgSQLParser.User_or_role_option_for_alterContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_or_role_or_group_common_option. + def enterUser_or_role_or_group_common_option( + self, ctx: PLpgSQLParser.User_or_role_or_group_common_optionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_or_role_or_group_common_option. + def exitUser_or_role_or_group_common_option( + self, ctx: PLpgSQLParser.User_or_role_or_group_common_optionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_or_role_common_option. + def enterUser_or_role_common_option( + self, ctx: PLpgSQLParser.User_or_role_common_optionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_or_role_common_option. + def exitUser_or_role_common_option( + self, ctx: PLpgSQLParser.User_or_role_common_optionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#user_or_role_or_group_option_for_create. + def enterUser_or_role_or_group_option_for_create( + self, ctx: PLpgSQLParser.User_or_role_or_group_option_for_createContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#user_or_role_or_group_option_for_create. + def exitUser_or_role_or_group_option_for_create( + self, ctx: PLpgSQLParser.User_or_role_or_group_option_for_createContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_group. + def enterCreate_group(self, ctx: PLpgSQLParser.Create_groupContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_group. + def exitCreate_group(self, ctx: PLpgSQLParser.Create_groupContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#group_option. + def enterGroup_option(self, ctx: PLpgSQLParser.Group_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#group_option. + def exitGroup_option(self, ctx: PLpgSQLParser.Group_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_tablespace. + def enterCreate_tablespace(self, ctx: PLpgSQLParser.Create_tablespaceContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_tablespace. + def exitCreate_tablespace(self, ctx: PLpgSQLParser.Create_tablespaceContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_statistics. + def enterCreate_statistics(self, ctx: PLpgSQLParser.Create_statisticsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_statistics. + def exitCreate_statistics(self, ctx: PLpgSQLParser.Create_statisticsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_foreign_data_wrapper. + def enterCreate_foreign_data_wrapper( + self, ctx: PLpgSQLParser.Create_foreign_data_wrapperContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_foreign_data_wrapper. + def exitCreate_foreign_data_wrapper( + self, ctx: PLpgSQLParser.Create_foreign_data_wrapperContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#option_without_equal. + def enterOption_without_equal(self, ctx: PLpgSQLParser.Option_without_equalContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#option_without_equal. + def exitOption_without_equal(self, ctx: PLpgSQLParser.Option_without_equalContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_operator_statement. + def enterCreate_operator_statement( + self, ctx: PLpgSQLParser.Create_operator_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_operator_statement. + def exitCreate_operator_statement( + self, ctx: PLpgSQLParser.Create_operator_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#operator_name. + def enterOperator_name(self, ctx: PLpgSQLParser.Operator_nameContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#operator_name. + def exitOperator_name(self, ctx: PLpgSQLParser.Operator_nameContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#operator_option. + def enterOperator_option(self, ctx: PLpgSQLParser.Operator_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#operator_option. + def exitOperator_option(self, ctx: PLpgSQLParser.Operator_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_aggregate_statement. + def enterCreate_aggregate_statement( + self, ctx: PLpgSQLParser.Create_aggregate_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_aggregate_statement. + def exitCreate_aggregate_statement( + self, ctx: PLpgSQLParser.Create_aggregate_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#aggregate_param. + def enterAggregate_param(self, ctx: PLpgSQLParser.Aggregate_paramContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#aggregate_param. + def exitAggregate_param(self, ctx: PLpgSQLParser.Aggregate_paramContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#set_statement. + def enterSet_statement(self, ctx: PLpgSQLParser.Set_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#set_statement. + def exitSet_statement(self, ctx: PLpgSQLParser.Set_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#set_action. + def enterSet_action(self, ctx: PLpgSQLParser.Set_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#set_action. + def exitSet_action(self, ctx: PLpgSQLParser.Set_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#session_local_option. + def enterSession_local_option(self, ctx: PLpgSQLParser.Session_local_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#session_local_option. + def exitSession_local_option(self, ctx: PLpgSQLParser.Session_local_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#set_statement_value. + def enterSet_statement_value(self, ctx: PLpgSQLParser.Set_statement_valueContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#set_statement_value. + def exitSet_statement_value(self, ctx: PLpgSQLParser.Set_statement_valueContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_rewrite_statement. + def enterCreate_rewrite_statement( + self, ctx: PLpgSQLParser.Create_rewrite_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_rewrite_statement. + def exitCreate_rewrite_statement( + self, ctx: PLpgSQLParser.Create_rewrite_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#rewrite_command. + def enterRewrite_command(self, ctx: PLpgSQLParser.Rewrite_commandContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#rewrite_command. + def exitRewrite_command(self, ctx: PLpgSQLParser.Rewrite_commandContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_trigger_statement. + def enterCreate_trigger_statement( + self, ctx: PLpgSQLParser.Create_trigger_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_trigger_statement. + def exitCreate_trigger_statement( + self, ctx: PLpgSQLParser.Create_trigger_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#trigger_referencing. + def enterTrigger_referencing(self, ctx: PLpgSQLParser.Trigger_referencingContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#trigger_referencing. + def exitTrigger_referencing(self, ctx: PLpgSQLParser.Trigger_referencingContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#when_trigger. + def enterWhen_trigger(self, ctx: PLpgSQLParser.When_triggerContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#when_trigger. + def exitWhen_trigger(self, ctx: PLpgSQLParser.When_triggerContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#rule_common. + def enterRule_common(self, ctx: PLpgSQLParser.Rule_commonContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#rule_common. + def exitRule_common(self, ctx: PLpgSQLParser.Rule_commonContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#rule_member_object. + def enterRule_member_object(self, ctx: PLpgSQLParser.Rule_member_objectContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#rule_member_object. + def exitRule_member_object(self, ctx: PLpgSQLParser.Rule_member_objectContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#columns_permissions. + def enterColumns_permissions(self, ctx: PLpgSQLParser.Columns_permissionsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#columns_permissions. + def exitColumns_permissions(self, ctx: PLpgSQLParser.Columns_permissionsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_column_privileges. + def enterTable_column_privileges( + self, ctx: PLpgSQLParser.Table_column_privilegesContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_column_privileges. + def exitTable_column_privileges( + self, ctx: PLpgSQLParser.Table_column_privilegesContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#permissions. + def enterPermissions(self, ctx: PLpgSQLParser.PermissionsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#permissions. + def exitPermissions(self, ctx: PLpgSQLParser.PermissionsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#permission. + def enterPermission(self, ctx: PLpgSQLParser.PermissionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#permission. + def exitPermission(self, ctx: PLpgSQLParser.PermissionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#other_rules. + def enterOther_rules(self, ctx: PLpgSQLParser.Other_rulesContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#other_rules. + def exitOther_rules(self, ctx: PLpgSQLParser.Other_rulesContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#grant_to_rule. + def enterGrant_to_rule(self, ctx: PLpgSQLParser.Grant_to_ruleContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#grant_to_rule. + def exitGrant_to_rule(self, ctx: PLpgSQLParser.Grant_to_ruleContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#revoke_from_cascade_restrict. + def enterRevoke_from_cascade_restrict( + self, ctx: PLpgSQLParser.Revoke_from_cascade_restrictContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#revoke_from_cascade_restrict. + def exitRevoke_from_cascade_restrict( + self, ctx: PLpgSQLParser.Revoke_from_cascade_restrictContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#roles_names. + def enterRoles_names(self, ctx: PLpgSQLParser.Roles_namesContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#roles_names. + def exitRoles_names(self, ctx: PLpgSQLParser.Roles_namesContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#role_name_with_group. + def enterRole_name_with_group(self, ctx: PLpgSQLParser.Role_name_with_groupContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#role_name_with_group. + def exitRole_name_with_group(self, ctx: PLpgSQLParser.Role_name_with_groupContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#comment_on_statement. + def enterComment_on_statement(self, ctx: PLpgSQLParser.Comment_on_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#comment_on_statement. + def exitComment_on_statement(self, ctx: PLpgSQLParser.Comment_on_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#security_label. + def enterSecurity_label(self, ctx: PLpgSQLParser.Security_labelContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#security_label. + def exitSecurity_label(self, ctx: PLpgSQLParser.Security_labelContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#comment_member_object. + def enterComment_member_object( + self, ctx: PLpgSQLParser.Comment_member_objectContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#comment_member_object. + def exitComment_member_object( + self, ctx: PLpgSQLParser.Comment_member_objectContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#label_member_object. + def enterLabel_member_object(self, ctx: PLpgSQLParser.Label_member_objectContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#label_member_object. + def exitLabel_member_object(self, ctx: PLpgSQLParser.Label_member_objectContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_function_statement. + def enterCreate_function_statement( + self, ctx: PLpgSQLParser.Create_function_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_function_statement. + def exitCreate_function_statement( + self, ctx: PLpgSQLParser.Create_function_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_funct_params. + def enterCreate_funct_params(self, ctx: PLpgSQLParser.Create_funct_paramsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_funct_params. + def exitCreate_funct_params(self, ctx: PLpgSQLParser.Create_funct_paramsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#transform_for_type. + def enterTransform_for_type(self, ctx: PLpgSQLParser.Transform_for_typeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#transform_for_type. + def exitTransform_for_type(self, ctx: PLpgSQLParser.Transform_for_typeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_ret_table. + def enterFunction_ret_table(self, ctx: PLpgSQLParser.Function_ret_tableContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_ret_table. + def exitFunction_ret_table(self, ctx: PLpgSQLParser.Function_ret_tableContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_column_name_type. + def enterFunction_column_name_type( + self, ctx: PLpgSQLParser.Function_column_name_typeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_column_name_type. + def exitFunction_column_name_type( + self, ctx: PLpgSQLParser.Function_column_name_typeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_parameters. + def enterFunction_parameters(self, ctx: PLpgSQLParser.Function_parametersContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_parameters. + def exitFunction_parameters(self, ctx: PLpgSQLParser.Function_parametersContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_args. + def enterFunction_args(self, ctx: PLpgSQLParser.Function_argsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_args. + def exitFunction_args(self, ctx: PLpgSQLParser.Function_argsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#agg_order. + def enterAgg_order(self, ctx: PLpgSQLParser.Agg_orderContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#agg_order. + def exitAgg_order(self, ctx: PLpgSQLParser.Agg_orderContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#character_string. + def enterCharacter_string(self, ctx: PLpgSQLParser.Character_stringContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#character_string. + def exitCharacter_string(self, ctx: PLpgSQLParser.Character_stringContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_arguments. + def enterFunction_arguments(self, ctx: PLpgSQLParser.Function_argumentsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_arguments. + def exitFunction_arguments(self, ctx: PLpgSQLParser.Function_argumentsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#argmode. + def enterArgmode(self, ctx: PLpgSQLParser.ArgmodeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#argmode. + def exitArgmode(self, ctx: PLpgSQLParser.ArgmodeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_sequence_statement. + def enterCreate_sequence_statement( + self, ctx: PLpgSQLParser.Create_sequence_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_sequence_statement. + def exitCreate_sequence_statement( + self, ctx: PLpgSQLParser.Create_sequence_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#sequence_body. + def enterSequence_body(self, ctx: PLpgSQLParser.Sequence_bodyContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#sequence_body. + def exitSequence_body(self, ctx: PLpgSQLParser.Sequence_bodyContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#signed_number_literal. + def enterSigned_number_literal( + self, ctx: PLpgSQLParser.Signed_number_literalContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#signed_number_literal. + def exitSigned_number_literal( + self, ctx: PLpgSQLParser.Signed_number_literalContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#signed_numerical_literal. + def enterSigned_numerical_literal( + self, ctx: PLpgSQLParser.Signed_numerical_literalContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#signed_numerical_literal. + def exitSigned_numerical_literal( + self, ctx: PLpgSQLParser.Signed_numerical_literalContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#sign. + def enterSign(self, ctx: PLpgSQLParser.SignContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#sign. + def exitSign(self, ctx: PLpgSQLParser.SignContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_schema_statement. + def enterCreate_schema_statement( + self, ctx: PLpgSQLParser.Create_schema_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_schema_statement. + def exitCreate_schema_statement( + self, ctx: PLpgSQLParser.Create_schema_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_policy_statement. + def enterCreate_policy_statement( + self, ctx: PLpgSQLParser.Create_policy_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_policy_statement. + def exitCreate_policy_statement( + self, ctx: PLpgSQLParser.Create_policy_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_policy_statement. + def enterAlter_policy_statement( + self, ctx: PLpgSQLParser.Alter_policy_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_policy_statement. + def exitAlter_policy_statement( + self, ctx: PLpgSQLParser.Alter_policy_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_policy_statement. + def enterDrop_policy_statement( + self, ctx: PLpgSQLParser.Drop_policy_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_policy_statement. + def exitDrop_policy_statement( + self, ctx: PLpgSQLParser.Drop_policy_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_subscription_statement. + def enterCreate_subscription_statement( + self, ctx: PLpgSQLParser.Create_subscription_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_subscription_statement. + def exitCreate_subscription_statement( + self, ctx: PLpgSQLParser.Create_subscription_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_subscription_statement. + def enterAlter_subscription_statement( + self, ctx: PLpgSQLParser.Alter_subscription_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_subscription_statement. + def exitAlter_subscription_statement( + self, ctx: PLpgSQLParser.Alter_subscription_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_subscription_action. + def enterAlter_subscription_action( + self, ctx: PLpgSQLParser.Alter_subscription_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_subscription_action. + def exitAlter_subscription_action( + self, ctx: PLpgSQLParser.Alter_subscription_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_cast_statement. + def enterCreate_cast_statement( + self, ctx: PLpgSQLParser.Create_cast_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_cast_statement. + def exitCreate_cast_statement( + self, ctx: PLpgSQLParser.Create_cast_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_cast_statement. + def enterDrop_cast_statement(self, ctx: PLpgSQLParser.Drop_cast_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_cast_statement. + def exitDrop_cast_statement(self, ctx: PLpgSQLParser.Drop_cast_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_operator_family_statement. + def enterCreate_operator_family_statement( + self, ctx: PLpgSQLParser.Create_operator_family_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_operator_family_statement. + def exitCreate_operator_family_statement( + self, ctx: PLpgSQLParser.Create_operator_family_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_operator_family_statement. + def enterAlter_operator_family_statement( + self, ctx: PLpgSQLParser.Alter_operator_family_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_operator_family_statement. + def exitAlter_operator_family_statement( + self, ctx: PLpgSQLParser.Alter_operator_family_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#operator_family_action. + def enterOperator_family_action( + self, ctx: PLpgSQLParser.Operator_family_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#operator_family_action. + def exitOperator_family_action( + self, ctx: PLpgSQLParser.Operator_family_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#add_operator_to_family. + def enterAdd_operator_to_family( + self, ctx: PLpgSQLParser.Add_operator_to_familyContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#add_operator_to_family. + def exitAdd_operator_to_family( + self, ctx: PLpgSQLParser.Add_operator_to_familyContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_operator_from_family. + def enterDrop_operator_from_family( + self, ctx: PLpgSQLParser.Drop_operator_from_familyContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_operator_from_family. + def exitDrop_operator_from_family( + self, ctx: PLpgSQLParser.Drop_operator_from_familyContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_operator_family_statement. + def enterDrop_operator_family_statement( + self, ctx: PLpgSQLParser.Drop_operator_family_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_operator_family_statement. + def exitDrop_operator_family_statement( + self, ctx: PLpgSQLParser.Drop_operator_family_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_operator_class_statement. + def enterCreate_operator_class_statement( + self, ctx: PLpgSQLParser.Create_operator_class_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_operator_class_statement. + def exitCreate_operator_class_statement( + self, ctx: PLpgSQLParser.Create_operator_class_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_operator_class_option. + def enterCreate_operator_class_option( + self, ctx: PLpgSQLParser.Create_operator_class_optionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_operator_class_option. + def exitCreate_operator_class_option( + self, ctx: PLpgSQLParser.Create_operator_class_optionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_operator_class_statement. + def enterAlter_operator_class_statement( + self, ctx: PLpgSQLParser.Alter_operator_class_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_operator_class_statement. + def exitAlter_operator_class_statement( + self, ctx: PLpgSQLParser.Alter_operator_class_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_operator_class_statement. + def enterDrop_operator_class_statement( + self, ctx: PLpgSQLParser.Drop_operator_class_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_operator_class_statement. + def exitDrop_operator_class_statement( + self, ctx: PLpgSQLParser.Drop_operator_class_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_conversion_statement. + def enterCreate_conversion_statement( + self, ctx: PLpgSQLParser.Create_conversion_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_conversion_statement. + def exitCreate_conversion_statement( + self, ctx: PLpgSQLParser.Create_conversion_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_conversion_statement. + def enterAlter_conversion_statement( + self, ctx: PLpgSQLParser.Alter_conversion_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_conversion_statement. + def exitAlter_conversion_statement( + self, ctx: PLpgSQLParser.Alter_conversion_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_publication_statement. + def enterCreate_publication_statement( + self, ctx: PLpgSQLParser.Create_publication_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_publication_statement. + def exitCreate_publication_statement( + self, ctx: PLpgSQLParser.Create_publication_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_publication_statement. + def enterAlter_publication_statement( + self, ctx: PLpgSQLParser.Alter_publication_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_publication_statement. + def exitAlter_publication_statement( + self, ctx: PLpgSQLParser.Alter_publication_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_publication_action. + def enterAlter_publication_action( + self, ctx: PLpgSQLParser.Alter_publication_actionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_publication_action. + def exitAlter_publication_action( + self, ctx: PLpgSQLParser.Alter_publication_actionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#only_table_multiply. + def enterOnly_table_multiply(self, ctx: PLpgSQLParser.Only_table_multiplyContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#only_table_multiply. + def exitOnly_table_multiply(self, ctx: PLpgSQLParser.Only_table_multiplyContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_trigger_statement. + def enterAlter_trigger_statement( + self, ctx: PLpgSQLParser.Alter_trigger_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_trigger_statement. + def exitAlter_trigger_statement( + self, ctx: PLpgSQLParser.Alter_trigger_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#alter_rule_statement. + def enterAlter_rule_statement(self, ctx: PLpgSQLParser.Alter_rule_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alter_rule_statement. + def exitAlter_rule_statement(self, ctx: PLpgSQLParser.Alter_rule_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#copy_statement. + def enterCopy_statement(self, ctx: PLpgSQLParser.Copy_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#copy_statement. + def exitCopy_statement(self, ctx: PLpgSQLParser.Copy_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#copy_from_statement. + def enterCopy_from_statement(self, ctx: PLpgSQLParser.Copy_from_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#copy_from_statement. + def exitCopy_from_statement(self, ctx: PLpgSQLParser.Copy_from_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#copy_to_statement. + def enterCopy_to_statement(self, ctx: PLpgSQLParser.Copy_to_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#copy_to_statement. + def exitCopy_to_statement(self, ctx: PLpgSQLParser.Copy_to_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#copy_option_list. + def enterCopy_option_list(self, ctx: PLpgSQLParser.Copy_option_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#copy_option_list. + def exitCopy_option_list(self, ctx: PLpgSQLParser.Copy_option_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#copy_option. + def enterCopy_option(self, ctx: PLpgSQLParser.Copy_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#copy_option. + def exitCopy_option(self, ctx: PLpgSQLParser.Copy_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_view_statement. + def enterCreate_view_statement( + self, ctx: PLpgSQLParser.Create_view_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_view_statement. + def exitCreate_view_statement( + self, ctx: PLpgSQLParser.Create_view_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#if_exists. + def enterIf_exists(self, ctx: PLpgSQLParser.If_existsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#if_exists. + def exitIf_exists(self, ctx: PLpgSQLParser.If_existsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#if_not_exists. + def enterIf_not_exists(self, ctx: PLpgSQLParser.If_not_existsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#if_not_exists. + def exitIf_not_exists(self, ctx: PLpgSQLParser.If_not_existsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#view_columns. + def enterView_columns(self, ctx: PLpgSQLParser.View_columnsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#view_columns. + def exitView_columns(self, ctx: PLpgSQLParser.View_columnsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#with_check_option. + def enterWith_check_option(self, ctx: PLpgSQLParser.With_check_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#with_check_option. + def exitWith_check_option(self, ctx: PLpgSQLParser.With_check_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_table_statement. + def enterCreate_table_statement( + self, ctx: PLpgSQLParser.Create_table_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_table_statement. + def exitCreate_table_statement( + self, ctx: PLpgSQLParser.Create_table_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_table_as_statement. + def enterCreate_table_as_statement( + self, ctx: PLpgSQLParser.Create_table_as_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_table_as_statement. + def exitCreate_table_as_statement( + self, ctx: PLpgSQLParser.Create_table_as_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#create_foreign_table_statement. + def enterCreate_foreign_table_statement( + self, ctx: PLpgSQLParser.Create_foreign_table_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#create_foreign_table_statement. + def exitCreate_foreign_table_statement( + self, ctx: PLpgSQLParser.Create_foreign_table_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#define_table. + def enterDefine_table(self, ctx: PLpgSQLParser.Define_tableContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#define_table. + def exitDefine_table(self, ctx: PLpgSQLParser.Define_tableContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#define_partition. + def enterDefine_partition(self, ctx: PLpgSQLParser.Define_partitionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#define_partition. + def exitDefine_partition(self, ctx: PLpgSQLParser.Define_partitionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#for_values_bound. + def enterFor_values_bound(self, ctx: PLpgSQLParser.For_values_boundContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#for_values_bound. + def exitFor_values_bound(self, ctx: PLpgSQLParser.For_values_boundContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#partition_bound_spec. + def enterPartition_bound_spec(self, ctx: PLpgSQLParser.Partition_bound_specContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#partition_bound_spec. + def exitPartition_bound_spec(self, ctx: PLpgSQLParser.Partition_bound_specContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#partition_bound_part. + def enterPartition_bound_part(self, ctx: PLpgSQLParser.Partition_bound_partContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#partition_bound_part. + def exitPartition_bound_part(self, ctx: PLpgSQLParser.Partition_bound_partContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#define_columns. + def enterDefine_columns(self, ctx: PLpgSQLParser.Define_columnsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#define_columns. + def exitDefine_columns(self, ctx: PLpgSQLParser.Define_columnsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#define_type. + def enterDefine_type(self, ctx: PLpgSQLParser.Define_typeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#define_type. + def exitDefine_type(self, ctx: PLpgSQLParser.Define_typeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#partition_by. + def enterPartition_by(self, ctx: PLpgSQLParser.Partition_byContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#partition_by. + def exitPartition_by(self, ctx: PLpgSQLParser.Partition_byContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#partition_method. + def enterPartition_method(self, ctx: PLpgSQLParser.Partition_methodContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#partition_method. + def exitPartition_method(self, ctx: PLpgSQLParser.Partition_methodContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#partition_column. + def enterPartition_column(self, ctx: PLpgSQLParser.Partition_columnContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#partition_column. + def exitPartition_column(self, ctx: PLpgSQLParser.Partition_columnContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#define_server. + def enterDefine_server(self, ctx: PLpgSQLParser.Define_serverContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#define_server. + def exitDefine_server(self, ctx: PLpgSQLParser.Define_serverContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#define_foreign_options. + def enterDefine_foreign_options( + self, ctx: PLpgSQLParser.Define_foreign_optionsContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#define_foreign_options. + def exitDefine_foreign_options( + self, ctx: PLpgSQLParser.Define_foreign_optionsContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#foreign_option. + def enterForeign_option(self, ctx: PLpgSQLParser.Foreign_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#foreign_option. + def exitForeign_option(self, ctx: PLpgSQLParser.Foreign_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#foreign_option_name. + def enterForeign_option_name(self, ctx: PLpgSQLParser.Foreign_option_nameContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#foreign_option_name. + def exitForeign_option_name(self, ctx: PLpgSQLParser.Foreign_option_nameContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#list_of_type_column_def. + def enterList_of_type_column_def( + self, ctx: PLpgSQLParser.List_of_type_column_defContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#list_of_type_column_def. + def exitList_of_type_column_def( + self, ctx: PLpgSQLParser.List_of_type_column_defContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_column_def. + def enterTable_column_def(self, ctx: PLpgSQLParser.Table_column_defContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_column_def. + def exitTable_column_def(self, ctx: PLpgSQLParser.Table_column_defContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_of_type_column_def. + def enterTable_of_type_column_def( + self, ctx: PLpgSQLParser.Table_of_type_column_defContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_of_type_column_def. + def exitTable_of_type_column_def( + self, ctx: PLpgSQLParser.Table_of_type_column_defContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_column_definition. + def enterTable_column_definition( + self, ctx: PLpgSQLParser.Table_column_definitionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_column_definition. + def exitTable_column_definition( + self, ctx: PLpgSQLParser.Table_column_definitionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#like_option. + def enterLike_option(self, ctx: PLpgSQLParser.Like_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#like_option. + def exitLike_option(self, ctx: PLpgSQLParser.Like_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#constraint_common. + def enterConstraint_common(self, ctx: PLpgSQLParser.Constraint_commonContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#constraint_common. + def exitConstraint_common(self, ctx: PLpgSQLParser.Constraint_commonContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#constr_body. + def enterConstr_body(self, ctx: PLpgSQLParser.Constr_bodyContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#constr_body. + def exitConstr_body(self, ctx: PLpgSQLParser.Constr_bodyContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#all_op. + def enterAll_op(self, ctx: PLpgSQLParser.All_opContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#all_op. + def exitAll_op(self, ctx: PLpgSQLParser.All_opContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#all_simple_op. + def enterAll_simple_op(self, ctx: PLpgSQLParser.All_simple_opContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#all_simple_op. + def exitAll_simple_op(self, ctx: PLpgSQLParser.All_simple_opContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#op_chars. + def enterOp_chars(self, ctx: PLpgSQLParser.Op_charsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#op_chars. + def exitOp_chars(self, ctx: PLpgSQLParser.Op_charsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#index_parameters. + def enterIndex_parameters(self, ctx: PLpgSQLParser.Index_parametersContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#index_parameters. + def exitIndex_parameters(self, ctx: PLpgSQLParser.Index_parametersContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#names_in_parens. + def enterNames_in_parens(self, ctx: PLpgSQLParser.Names_in_parensContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#names_in_parens. + def exitNames_in_parens(self, ctx: PLpgSQLParser.Names_in_parensContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#names_references. + def enterNames_references(self, ctx: PLpgSQLParser.Names_referencesContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#names_references. + def exitNames_references(self, ctx: PLpgSQLParser.Names_referencesContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#storage_parameter. + def enterStorage_parameter(self, ctx: PLpgSQLParser.Storage_parameterContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#storage_parameter. + def exitStorage_parameter(self, ctx: PLpgSQLParser.Storage_parameterContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#storage_parameter_option. + def enterStorage_parameter_option( + self, ctx: PLpgSQLParser.Storage_parameter_optionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#storage_parameter_option. + def exitStorage_parameter_option( + self, ctx: PLpgSQLParser.Storage_parameter_optionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#storage_parameter_name. + def enterStorage_parameter_name( + self, ctx: PLpgSQLParser.Storage_parameter_nameContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#storage_parameter_name. + def exitStorage_parameter_name( + self, ctx: PLpgSQLParser.Storage_parameter_nameContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#with_storage_parameter. + def enterWith_storage_parameter( + self, ctx: PLpgSQLParser.With_storage_parameterContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#with_storage_parameter. + def exitWith_storage_parameter( + self, ctx: PLpgSQLParser.With_storage_parameterContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#storage_parameter_oid. + def enterStorage_parameter_oid( + self, ctx: PLpgSQLParser.Storage_parameter_oidContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#storage_parameter_oid. + def exitStorage_parameter_oid( + self, ctx: PLpgSQLParser.Storage_parameter_oidContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#on_commit. + def enterOn_commit(self, ctx: PLpgSQLParser.On_commitContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#on_commit. + def exitOn_commit(self, ctx: PLpgSQLParser.On_commitContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_space. + def enterTable_space(self, ctx: PLpgSQLParser.Table_spaceContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_space. + def exitTable_space(self, ctx: PLpgSQLParser.Table_spaceContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#action. + def enterAction(self, ctx: PLpgSQLParser.ActionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#action. + def exitAction(self, ctx: PLpgSQLParser.ActionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#owner_to. + def enterOwner_to(self, ctx: PLpgSQLParser.Owner_toContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#owner_to. + def exitOwner_to(self, ctx: PLpgSQLParser.Owner_toContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#rename_to. + def enterRename_to(self, ctx: PLpgSQLParser.Rename_toContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#rename_to. + def exitRename_to(self, ctx: PLpgSQLParser.Rename_toContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#set_schema. + def enterSet_schema(self, ctx: PLpgSQLParser.Set_schemaContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#set_schema. + def exitSet_schema(self, ctx: PLpgSQLParser.Set_schemaContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_column_privilege. + def enterTable_column_privilege( + self, ctx: PLpgSQLParser.Table_column_privilegeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_column_privilege. + def exitTable_column_privilege( + self, ctx: PLpgSQLParser.Table_column_privilegeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#usage_select_update. + def enterUsage_select_update(self, ctx: PLpgSQLParser.Usage_select_updateContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#usage_select_update. + def exitUsage_select_update(self, ctx: PLpgSQLParser.Usage_select_updateContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#partition_by_columns. + def enterPartition_by_columns(self, ctx: PLpgSQLParser.Partition_by_columnsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#partition_by_columns. + def exitPartition_by_columns(self, ctx: PLpgSQLParser.Partition_by_columnsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#cascade_restrict. + def enterCascade_restrict(self, ctx: PLpgSQLParser.Cascade_restrictContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#cascade_restrict. + def exitCascade_restrict(self, ctx: PLpgSQLParser.Cascade_restrictContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#collate_identifier. + def enterCollate_identifier(self, ctx: PLpgSQLParser.Collate_identifierContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#collate_identifier. + def exitCollate_identifier(self, ctx: PLpgSQLParser.Collate_identifierContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#indirection_var. + def enterIndirection_var(self, ctx: PLpgSQLParser.Indirection_varContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#indirection_var. + def exitIndirection_var(self, ctx: PLpgSQLParser.Indirection_varContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#dollar_number. + def enterDollar_number(self, ctx: PLpgSQLParser.Dollar_numberContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#dollar_number. + def exitDollar_number(self, ctx: PLpgSQLParser.Dollar_numberContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#indirection_list. + def enterIndirection_list(self, ctx: PLpgSQLParser.Indirection_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#indirection_list. + def exitIndirection_list(self, ctx: PLpgSQLParser.Indirection_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#indirection. + def enterIndirection(self, ctx: PLpgSQLParser.IndirectionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#indirection. + def exitIndirection(self, ctx: PLpgSQLParser.IndirectionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_function_statement. + def enterDrop_function_statement( + self, ctx: PLpgSQLParser.Drop_function_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_function_statement. + def exitDrop_function_statement( + self, ctx: PLpgSQLParser.Drop_function_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_trigger_statement. + def enterDrop_trigger_statement( + self, ctx: PLpgSQLParser.Drop_trigger_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_trigger_statement. + def exitDrop_trigger_statement( + self, ctx: PLpgSQLParser.Drop_trigger_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_rule_statement. + def enterDrop_rule_statement(self, ctx: PLpgSQLParser.Drop_rule_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_rule_statement. + def exitDrop_rule_statement(self, ctx: PLpgSQLParser.Drop_rule_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#drop_statements. + def enterDrop_statements(self, ctx: PLpgSQLParser.Drop_statementsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#drop_statements. + def exitDrop_statements(self, ctx: PLpgSQLParser.Drop_statementsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#if_exist_names_restrict_cascade. + def enterIf_exist_names_restrict_cascade( + self, ctx: PLpgSQLParser.If_exist_names_restrict_cascadeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#if_exist_names_restrict_cascade. + def exitIf_exist_names_restrict_cascade( + self, ctx: PLpgSQLParser.If_exist_names_restrict_cascadeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#id_token. + def enterId_token(self, ctx: PLpgSQLParser.Id_tokenContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#id_token. + def exitId_token(self, ctx: PLpgSQLParser.Id_tokenContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#identifier. + def enterIdentifier(self, ctx: PLpgSQLParser.IdentifierContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#identifier. + def exitIdentifier(self, ctx: PLpgSQLParser.IdentifierContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#identifier_nontype. + def enterIdentifier_nontype(self, ctx: PLpgSQLParser.Identifier_nontypeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#identifier_nontype. + def exitIdentifier_nontype(self, ctx: PLpgSQLParser.Identifier_nontypeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#col_label. + def enterCol_label(self, ctx: PLpgSQLParser.Col_labelContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#col_label. + def exitCol_label(self, ctx: PLpgSQLParser.Col_labelContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#tokens_nonreserved. + def enterTokens_nonreserved(self, ctx: PLpgSQLParser.Tokens_nonreservedContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#tokens_nonreserved. + def exitTokens_nonreserved(self, ctx: PLpgSQLParser.Tokens_nonreservedContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#tokens_nonreserved_except_function_type. + def enterTokens_nonreserved_except_function_type( + self, ctx: PLpgSQLParser.Tokens_nonreserved_except_function_typeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#tokens_nonreserved_except_function_type. + def exitTokens_nonreserved_except_function_type( + self, ctx: PLpgSQLParser.Tokens_nonreserved_except_function_typeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#tokens_reserved_except_function_type. + def enterTokens_reserved_except_function_type( + self, ctx: PLpgSQLParser.Tokens_reserved_except_function_typeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#tokens_reserved_except_function_type. + def exitTokens_reserved_except_function_type( + self, ctx: PLpgSQLParser.Tokens_reserved_except_function_typeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#tokens_reserved. + def enterTokens_reserved(self, ctx: PLpgSQLParser.Tokens_reservedContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#tokens_reserved. + def exitTokens_reserved(self, ctx: PLpgSQLParser.Tokens_reservedContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#tokens_nonkeyword. + def enterTokens_nonkeyword(self, ctx: PLpgSQLParser.Tokens_nonkeywordContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#tokens_nonkeyword. + def exitTokens_nonkeyword(self, ctx: PLpgSQLParser.Tokens_nonkeywordContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_qualified_name_nontype. + def enterSchema_qualified_name_nontype( + self, ctx: PLpgSQLParser.Schema_qualified_name_nontypeContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_qualified_name_nontype. + def exitSchema_qualified_name_nontype( + self, ctx: PLpgSQLParser.Schema_qualified_name_nontypeContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#type_list. + def enterType_list(self, ctx: PLpgSQLParser.Type_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#type_list. + def exitType_list(self, ctx: PLpgSQLParser.Type_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#data_type. + def enterData_type(self, ctx: PLpgSQLParser.Data_typeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#data_type. + def exitData_type(self, ctx: PLpgSQLParser.Data_typeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#array_type. + def enterArray_type(self, ctx: PLpgSQLParser.Array_typeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#array_type. + def exitArray_type(self, ctx: PLpgSQLParser.Array_typeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#predefined_type. + def enterPredefined_type(self, ctx: PLpgSQLParser.Predefined_typeContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#predefined_type. + def exitPredefined_type(self, ctx: PLpgSQLParser.Predefined_typeContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#interval_field. + def enterInterval_field(self, ctx: PLpgSQLParser.Interval_fieldContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#interval_field. + def exitInterval_field(self, ctx: PLpgSQLParser.Interval_fieldContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#type_length. + def enterType_length(self, ctx: PLpgSQLParser.Type_lengthContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#type_length. + def exitType_length(self, ctx: PLpgSQLParser.Type_lengthContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#precision_param. + def enterPrecision_param(self, ctx: PLpgSQLParser.Precision_paramContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#precision_param. + def exitPrecision_param(self, ctx: PLpgSQLParser.Precision_paramContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#vex. + def enterVex(self, ctx: PLpgSQLParser.VexContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#vex. + def exitVex(self, ctx: PLpgSQLParser.VexContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#vex_b. + def enterVex_b(self, ctx: PLpgSQLParser.Vex_bContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#vex_b. + def exitVex_b(self, ctx: PLpgSQLParser.Vex_bContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#op. + def enterOp(self, ctx: PLpgSQLParser.OpContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#op. + def exitOp(self, ctx: PLpgSQLParser.OpContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#all_op_ref. + def enterAll_op_ref(self, ctx: PLpgSQLParser.All_op_refContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#all_op_ref. + def exitAll_op_ref(self, ctx: PLpgSQLParser.All_op_refContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#datetime_overlaps. + def enterDatetime_overlaps(self, ctx: PLpgSQLParser.Datetime_overlapsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#datetime_overlaps. + def exitDatetime_overlaps(self, ctx: PLpgSQLParser.Datetime_overlapsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#value_expression_primary. + def enterValue_expression_primary( + self, ctx: PLpgSQLParser.Value_expression_primaryContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#value_expression_primary. + def exitValue_expression_primary( + self, ctx: PLpgSQLParser.Value_expression_primaryContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#unsigned_value_specification. + def enterUnsigned_value_specification( + self, ctx: PLpgSQLParser.Unsigned_value_specificationContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#unsigned_value_specification. + def exitUnsigned_value_specification( + self, ctx: PLpgSQLParser.Unsigned_value_specificationContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#unsigned_numeric_literal. + def enterUnsigned_numeric_literal( + self, ctx: PLpgSQLParser.Unsigned_numeric_literalContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#unsigned_numeric_literal. + def exitUnsigned_numeric_literal( + self, ctx: PLpgSQLParser.Unsigned_numeric_literalContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#truth_value. + def enterTruth_value(self, ctx: PLpgSQLParser.Truth_valueContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#truth_value. + def exitTruth_value(self, ctx: PLpgSQLParser.Truth_valueContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#case_expression. + def enterCase_expression(self, ctx: PLpgSQLParser.Case_expressionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#case_expression. + def exitCase_expression(self, ctx: PLpgSQLParser.Case_expressionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#cast_specification. + def enterCast_specification(self, ctx: PLpgSQLParser.Cast_specificationContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#cast_specification. + def exitCast_specification(self, ctx: PLpgSQLParser.Cast_specificationContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_call. + def enterFunction_call(self, ctx: PLpgSQLParser.Function_callContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_call. + def exitFunction_call(self, ctx: PLpgSQLParser.Function_callContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#vex_or_named_notation. + def enterVex_or_named_notation( + self, ctx: PLpgSQLParser.Vex_or_named_notationContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#vex_or_named_notation. + def exitVex_or_named_notation( + self, ctx: PLpgSQLParser.Vex_or_named_notationContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#pointer. + def enterPointer(self, ctx: PLpgSQLParser.PointerContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#pointer. + def exitPointer(self, ctx: PLpgSQLParser.PointerContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_construct. + def enterFunction_construct(self, ctx: PLpgSQLParser.Function_constructContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_construct. + def exitFunction_construct(self, ctx: PLpgSQLParser.Function_constructContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#extract_function. + def enterExtract_function(self, ctx: PLpgSQLParser.Extract_functionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#extract_function. + def exitExtract_function(self, ctx: PLpgSQLParser.Extract_functionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#system_function. + def enterSystem_function(self, ctx: PLpgSQLParser.System_functionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#system_function. + def exitSystem_function(self, ctx: PLpgSQLParser.System_functionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#date_time_function. + def enterDate_time_function(self, ctx: PLpgSQLParser.Date_time_functionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#date_time_function. + def exitDate_time_function(self, ctx: PLpgSQLParser.Date_time_functionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#string_value_function. + def enterString_value_function( + self, ctx: PLpgSQLParser.String_value_functionContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#string_value_function. + def exitString_value_function( + self, ctx: PLpgSQLParser.String_value_functionContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#xml_function. + def enterXml_function(self, ctx: PLpgSQLParser.Xml_functionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#xml_function. + def exitXml_function(self, ctx: PLpgSQLParser.Xml_functionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#xml_table_column. + def enterXml_table_column(self, ctx: PLpgSQLParser.Xml_table_columnContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#xml_table_column. + def exitXml_table_column(self, ctx: PLpgSQLParser.Xml_table_columnContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#comparison_mod. + def enterComparison_mod(self, ctx: PLpgSQLParser.Comparison_modContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#comparison_mod. + def exitComparison_mod(self, ctx: PLpgSQLParser.Comparison_modContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#filter_clause. + def enterFilter_clause(self, ctx: PLpgSQLParser.Filter_clauseContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#filter_clause. + def exitFilter_clause(self, ctx: PLpgSQLParser.Filter_clauseContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#window_definition. + def enterWindow_definition(self, ctx: PLpgSQLParser.Window_definitionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#window_definition. + def exitWindow_definition(self, ctx: PLpgSQLParser.Window_definitionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#frame_clause. + def enterFrame_clause(self, ctx: PLpgSQLParser.Frame_clauseContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#frame_clause. + def exitFrame_clause(self, ctx: PLpgSQLParser.Frame_clauseContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#frame_bound. + def enterFrame_bound(self, ctx: PLpgSQLParser.Frame_boundContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#frame_bound. + def exitFrame_bound(self, ctx: PLpgSQLParser.Frame_boundContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#array_expression. + def enterArray_expression(self, ctx: PLpgSQLParser.Array_expressionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#array_expression. + def exitArray_expression(self, ctx: PLpgSQLParser.Array_expressionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#array_elements. + def enterArray_elements(self, ctx: PLpgSQLParser.Array_elementsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#array_elements. + def exitArray_elements(self, ctx: PLpgSQLParser.Array_elementsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#type_coercion. + def enterType_coercion(self, ctx: PLpgSQLParser.Type_coercionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#type_coercion. + def exitType_coercion(self, ctx: PLpgSQLParser.Type_coercionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#schema_qualified_name. + def enterSchema_qualified_name( + self, ctx: PLpgSQLParser.Schema_qualified_nameContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#schema_qualified_name. + def exitSchema_qualified_name( + self, ctx: PLpgSQLParser.Schema_qualified_nameContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#set_qualifier. + def enterSet_qualifier(self, ctx: PLpgSQLParser.Set_qualifierContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#set_qualifier. + def exitSet_qualifier(self, ctx: PLpgSQLParser.Set_qualifierContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#table_subquery. + def enterTable_subquery(self, ctx: PLpgSQLParser.Table_subqueryContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#table_subquery. + def exitTable_subquery(self, ctx: PLpgSQLParser.Table_subqueryContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_stmt. + def enterSelect_stmt(self, ctx: PLpgSQLParser.Select_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_stmt. + def exitSelect_stmt(self, ctx: PLpgSQLParser.Select_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#after_ops. + def enterAfter_ops(self, ctx: PLpgSQLParser.After_opsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#after_ops. + def exitAfter_ops(self, ctx: PLpgSQLParser.After_opsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_stmt_no_parens. + def enterSelect_stmt_no_parens( + self, ctx: PLpgSQLParser.Select_stmt_no_parensContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_stmt_no_parens. + def exitSelect_stmt_no_parens( + self, ctx: PLpgSQLParser.Select_stmt_no_parensContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#with_clause. + def enterWith_clause(self, ctx: PLpgSQLParser.With_clauseContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#with_clause. + def exitWith_clause(self, ctx: PLpgSQLParser.With_clauseContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#with_query. + def enterWith_query(self, ctx: PLpgSQLParser.With_queryContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#with_query. + def exitWith_query(self, ctx: PLpgSQLParser.With_queryContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_ops. + def enterSelect_ops(self, ctx: PLpgSQLParser.Select_opsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_ops. + def exitSelect_ops(self, ctx: PLpgSQLParser.Select_opsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_ops_no_parens. + def enterSelect_ops_no_parens(self, ctx: PLpgSQLParser.Select_ops_no_parensContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_ops_no_parens. + def exitSelect_ops_no_parens(self, ctx: PLpgSQLParser.Select_ops_no_parensContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_primary. + def enterSelect_primary(self, ctx: PLpgSQLParser.Select_primaryContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_primary. + def exitSelect_primary(self, ctx: PLpgSQLParser.Select_primaryContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_list. + def enterSelect_list(self, ctx: PLpgSQLParser.Select_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_list. + def exitSelect_list(self, ctx: PLpgSQLParser.Select_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#select_sublist. + def enterSelect_sublist(self, ctx: PLpgSQLParser.Select_sublistContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#select_sublist. + def exitSelect_sublist(self, ctx: PLpgSQLParser.Select_sublistContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#into_table. + def enterInto_table(self, ctx: PLpgSQLParser.Into_tableContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#into_table. + def exitInto_table(self, ctx: PLpgSQLParser.Into_tableContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#from_item. + def enterFrom_item(self, ctx: PLpgSQLParser.From_itemContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#from_item. + def exitFrom_item(self, ctx: PLpgSQLParser.From_itemContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#from_primary. + def enterFrom_primary(self, ctx: PLpgSQLParser.From_primaryContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#from_primary. + def exitFrom_primary(self, ctx: PLpgSQLParser.From_primaryContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#alias_clause. + def enterAlias_clause(self, ctx: PLpgSQLParser.Alias_clauseContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#alias_clause. + def exitAlias_clause(self, ctx: PLpgSQLParser.Alias_clauseContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#from_function_column_def. + def enterFrom_function_column_def( + self, ctx: PLpgSQLParser.From_function_column_defContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#from_function_column_def. + def exitFrom_function_column_def( + self, ctx: PLpgSQLParser.From_function_column_defContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#groupby_clause. + def enterGroupby_clause(self, ctx: PLpgSQLParser.Groupby_clauseContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#groupby_clause. + def exitGroupby_clause(self, ctx: PLpgSQLParser.Groupby_clauseContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#grouping_element_list. + def enterGrouping_element_list( + self, ctx: PLpgSQLParser.Grouping_element_listContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#grouping_element_list. + def exitGrouping_element_list( + self, ctx: PLpgSQLParser.Grouping_element_listContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#grouping_element. + def enterGrouping_element(self, ctx: PLpgSQLParser.Grouping_elementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#grouping_element. + def exitGrouping_element(self, ctx: PLpgSQLParser.Grouping_elementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#values_stmt. + def enterValues_stmt(self, ctx: PLpgSQLParser.Values_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#values_stmt. + def exitValues_stmt(self, ctx: PLpgSQLParser.Values_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#values_values. + def enterValues_values(self, ctx: PLpgSQLParser.Values_valuesContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#values_values. + def exitValues_values(self, ctx: PLpgSQLParser.Values_valuesContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#orderby_clause. + def enterOrderby_clause(self, ctx: PLpgSQLParser.Orderby_clauseContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#orderby_clause. + def exitOrderby_clause(self, ctx: PLpgSQLParser.Orderby_clauseContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#sort_specifier_list. + def enterSort_specifier_list(self, ctx: PLpgSQLParser.Sort_specifier_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#sort_specifier_list. + def exitSort_specifier_list(self, ctx: PLpgSQLParser.Sort_specifier_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#sort_specifier. + def enterSort_specifier(self, ctx: PLpgSQLParser.Sort_specifierContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#sort_specifier. + def exitSort_specifier(self, ctx: PLpgSQLParser.Sort_specifierContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#order_specification. + def enterOrder_specification(self, ctx: PLpgSQLParser.Order_specificationContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#order_specification. + def exitOrder_specification(self, ctx: PLpgSQLParser.Order_specificationContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#null_ordering. + def enterNull_ordering(self, ctx: PLpgSQLParser.Null_orderingContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#null_ordering. + def exitNull_ordering(self, ctx: PLpgSQLParser.Null_orderingContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#insert_stmt_for_psql. + def enterInsert_stmt_for_psql(self, ctx: PLpgSQLParser.Insert_stmt_for_psqlContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#insert_stmt_for_psql. + def exitInsert_stmt_for_psql(self, ctx: PLpgSQLParser.Insert_stmt_for_psqlContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#insert_columns. + def enterInsert_columns(self, ctx: PLpgSQLParser.Insert_columnsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#insert_columns. + def exitInsert_columns(self, ctx: PLpgSQLParser.Insert_columnsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#indirection_identifier. + def enterIndirection_identifier( + self, ctx: PLpgSQLParser.Indirection_identifierContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#indirection_identifier. + def exitIndirection_identifier( + self, ctx: PLpgSQLParser.Indirection_identifierContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#conflict_object. + def enterConflict_object(self, ctx: PLpgSQLParser.Conflict_objectContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#conflict_object. + def exitConflict_object(self, ctx: PLpgSQLParser.Conflict_objectContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#conflict_action. + def enterConflict_action(self, ctx: PLpgSQLParser.Conflict_actionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#conflict_action. + def exitConflict_action(self, ctx: PLpgSQLParser.Conflict_actionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#delete_stmt_for_psql. + def enterDelete_stmt_for_psql(self, ctx: PLpgSQLParser.Delete_stmt_for_psqlContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#delete_stmt_for_psql. + def exitDelete_stmt_for_psql(self, ctx: PLpgSQLParser.Delete_stmt_for_psqlContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#update_stmt_for_psql. + def enterUpdate_stmt_for_psql(self, ctx: PLpgSQLParser.Update_stmt_for_psqlContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#update_stmt_for_psql. + def exitUpdate_stmt_for_psql(self, ctx: PLpgSQLParser.Update_stmt_for_psqlContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#update_set. + def enterUpdate_set(self, ctx: PLpgSQLParser.Update_setContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#update_set. + def exitUpdate_set(self, ctx: PLpgSQLParser.Update_setContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#notify_stmt. + def enterNotify_stmt(self, ctx: PLpgSQLParser.Notify_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#notify_stmt. + def exitNotify_stmt(self, ctx: PLpgSQLParser.Notify_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#truncate_stmt. + def enterTruncate_stmt(self, ctx: PLpgSQLParser.Truncate_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#truncate_stmt. + def exitTruncate_stmt(self, ctx: PLpgSQLParser.Truncate_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#identifier_list. + def enterIdentifier_list(self, ctx: PLpgSQLParser.Identifier_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#identifier_list. + def exitIdentifier_list(self, ctx: PLpgSQLParser.Identifier_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#anonymous_block. + def enterAnonymous_block(self, ctx: PLpgSQLParser.Anonymous_blockContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#anonymous_block. + def exitAnonymous_block(self, ctx: PLpgSQLParser.Anonymous_blockContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#comp_options. + def enterComp_options(self, ctx: PLpgSQLParser.Comp_optionsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#comp_options. + def exitComp_options(self, ctx: PLpgSQLParser.Comp_optionsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_block. + def enterFunction_block(self, ctx: PLpgSQLParser.Function_blockContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_block. + def exitFunction_block(self, ctx: PLpgSQLParser.Function_blockContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#start_label. + def enterStart_label(self, ctx: PLpgSQLParser.Start_labelContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#start_label. + def exitStart_label(self, ctx: PLpgSQLParser.Start_labelContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#declarations. + def enterDeclarations(self, ctx: PLpgSQLParser.DeclarationsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#declarations. + def exitDeclarations(self, ctx: PLpgSQLParser.DeclarationsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#declaration. + def enterDeclaration(self, ctx: PLpgSQLParser.DeclarationContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#declaration. + def exitDeclaration(self, ctx: PLpgSQLParser.DeclarationContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#type_declaration. + def enterType_declaration(self, ctx: PLpgSQLParser.Type_declarationContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#type_declaration. + def exitType_declaration(self, ctx: PLpgSQLParser.Type_declarationContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#arguments_list. + def enterArguments_list(self, ctx: PLpgSQLParser.Arguments_listContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#arguments_list. + def exitArguments_list(self, ctx: PLpgSQLParser.Arguments_listContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#data_type_dec. + def enterData_type_dec(self, ctx: PLpgSQLParser.Data_type_decContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#data_type_dec. + def exitData_type_dec(self, ctx: PLpgSQLParser.Data_type_decContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#exception_statement. + def enterException_statement(self, ctx: PLpgSQLParser.Exception_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#exception_statement. + def exitException_statement(self, ctx: PLpgSQLParser.Exception_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_statements. + def enterFunction_statements(self, ctx: PLpgSQLParser.Function_statementsContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_statements. + def exitFunction_statements(self, ctx: PLpgSQLParser.Function_statementsContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#function_statement. + def enterFunction_statement(self, ctx: PLpgSQLParser.Function_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#function_statement. + def exitFunction_statement(self, ctx: PLpgSQLParser.Function_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#base_statement. + def enterBase_statement(self, ctx: PLpgSQLParser.Base_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#base_statement. + def exitBase_statement(self, ctx: PLpgSQLParser.Base_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#var. + def enterVar(self, ctx: PLpgSQLParser.VarContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#var. + def exitVar(self, ctx: PLpgSQLParser.VarContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#diagnostic_option. + def enterDiagnostic_option(self, ctx: PLpgSQLParser.Diagnostic_optionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#diagnostic_option. + def exitDiagnostic_option(self, ctx: PLpgSQLParser.Diagnostic_optionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#perform_stmt. + def enterPerform_stmt(self, ctx: PLpgSQLParser.Perform_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#perform_stmt. + def exitPerform_stmt(self, ctx: PLpgSQLParser.Perform_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#assign_stmt. + def enterAssign_stmt(self, ctx: PLpgSQLParser.Assign_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#assign_stmt. + def exitAssign_stmt(self, ctx: PLpgSQLParser.Assign_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#execute_stmt. + def enterExecute_stmt(self, ctx: PLpgSQLParser.Execute_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#execute_stmt. + def exitExecute_stmt(self, ctx: PLpgSQLParser.Execute_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#control_statement. + def enterControl_statement(self, ctx: PLpgSQLParser.Control_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#control_statement. + def exitControl_statement(self, ctx: PLpgSQLParser.Control_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#cursor_statement. + def enterCursor_statement(self, ctx: PLpgSQLParser.Cursor_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#cursor_statement. + def exitCursor_statement(self, ctx: PLpgSQLParser.Cursor_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#option. + def enterOption(self, ctx: PLpgSQLParser.OptionContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#option. + def exitOption(self, ctx: PLpgSQLParser.OptionContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#transaction_statement. + def enterTransaction_statement( + self, ctx: PLpgSQLParser.Transaction_statementContext + ): + pass + + # Exit a parse tree produced by PLpgSQLParser#transaction_statement. + def exitTransaction_statement( + self, ctx: PLpgSQLParser.Transaction_statementContext + ): + pass + + # Enter a parse tree produced by PLpgSQLParser#message_statement. + def enterMessage_statement(self, ctx: PLpgSQLParser.Message_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#message_statement. + def exitMessage_statement(self, ctx: PLpgSQLParser.Message_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#log_level. + def enterLog_level(self, ctx: PLpgSQLParser.Log_levelContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#log_level. + def exitLog_level(self, ctx: PLpgSQLParser.Log_levelContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#raise_using. + def enterRaise_using(self, ctx: PLpgSQLParser.Raise_usingContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#raise_using. + def exitRaise_using(self, ctx: PLpgSQLParser.Raise_usingContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#raise_param. + def enterRaise_param(self, ctx: PLpgSQLParser.Raise_paramContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#raise_param. + def exitRaise_param(self, ctx: PLpgSQLParser.Raise_paramContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#return_stmt. + def enterReturn_stmt(self, ctx: PLpgSQLParser.Return_stmtContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#return_stmt. + def exitReturn_stmt(self, ctx: PLpgSQLParser.Return_stmtContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#loop_statement. + def enterLoop_statement(self, ctx: PLpgSQLParser.Loop_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#loop_statement. + def exitLoop_statement(self, ctx: PLpgSQLParser.Loop_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#loop_start. + def enterLoop_start(self, ctx: PLpgSQLParser.Loop_startContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#loop_start. + def exitLoop_start(self, ctx: PLpgSQLParser.Loop_startContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#using_vex. + def enterUsing_vex(self, ctx: PLpgSQLParser.Using_vexContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#using_vex. + def exitUsing_vex(self, ctx: PLpgSQLParser.Using_vexContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#if_statement. + def enterIf_statement(self, ctx: PLpgSQLParser.If_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#if_statement. + def exitIf_statement(self, ctx: PLpgSQLParser.If_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#case_statement. + def enterCase_statement(self, ctx: PLpgSQLParser.Case_statementContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#case_statement. + def exitCase_statement(self, ctx: PLpgSQLParser.Case_statementContext): + pass + + # Enter a parse tree produced by PLpgSQLParser#plpgsql_query. + def enterPlpgsql_query(self, ctx: PLpgSQLParser.Plpgsql_queryContext): + pass + + # Exit a parse tree produced by PLpgSQLParser#plpgsql_query. + def exitPlpgsql_query(self, ctx: PLpgSQLParser.Plpgsql_queryContext): + pass + + +del PLpgSQLParser diff --git a/sql_to_code/parsers/generated/README.md b/sql_to_code/parsers/generated/README.md new file mode 100644 index 0000000..eaaf4e7 --- /dev/null +++ b/sql_to_code/parsers/generated/README.md @@ -0,0 +1,22 @@ +This SQL parser is generated with [ANTLR v4 tool](https://github.com/antlr/antlr4) from [PL/SQL grammar](https://github.com/antlr/grammars-v4/tree/master/sql/plsql). + +Exact steps: + +```shell + +# download grammar files +curl -O https://raw.githubusercontent.com/modeldba/antlr4ts-sql/main/src/grammars/plpgsql/PLpgSQLLexer.g4 +curl -O https://raw.githubusercontent.com/modeldba/antlr4ts-sql/main/src/grammars/plpgsql/PLpgSQLParser.g4 + +# manually remove Java things from these files... + +# download antlr v4 tool +curl -O https://www.antlr.org/download/antlr-4.9-complete.jar + +# generate python3 parser +java -Xmx500M -cp antlr-4.9-complete.jar org.antlr.v4.Tool PLpgSQLLexer.g4 -o ./ -Dlanguage=Python3 +java -Xmx500M -cp antlr-4.9-complete.jar org.antlr.v4.Tool PLpgSQLParser.g4 -o ./ -Dlanguage=Python3 + +``` + +Additionally, you need to manually create PlSqlLexerBase.py and PlSqlParserBase.py files. diff --git a/sql_to_code/parsers/generated/__init__.py b/sql_to_code/parsers/generated/__init__.py new file mode 100644 index 0000000..76ee73a --- /dev/null +++ b/sql_to_code/parsers/generated/__init__.py @@ -0,0 +1 @@ +from .parser import parse_commands diff --git a/sql_to_code/parsers/generated/parser.py b/sql_to_code/parsers/generated/parser.py new file mode 100644 index 0000000..9231703 --- /dev/null +++ b/sql_to_code/parsers/generated/parser.py @@ -0,0 +1,51 @@ +from antlr4 import CommonTokenStream, InputStream, LexerATNSimulator, ParseTreeWalker + +from ...models import Context +from .PLpgSQLLexer import PLpgSQLLexer +from .PLpgSQLParser import PLpgSQLParser +from .PLpgSQLParserListener import PLpgSQLParserListener + + +class Listener(PLpgSQLParserListener): + def __init__(self, context: Context): + self.__context = context + + def enterCreate_table_statement(self, ctx: PLpgSQLParser.create_table_statement): + print("\n\n=====\nenterCreate_table") + + def exitCreate_table_statement(self, ctx: PLpgSQLParser.create_table_statement): + print("\n\n=====\nexitCreate_table_statement") + print("create table", ctx.name.getText()) + for item in ctx.define_table().define_columns().children: + if not isinstance(item, PLpgSQLParser.Table_column_defContext): + continue + print("name", item.table_column_definition().identifier().getText()) + print("datatype", item.table_column_definition().data_type().getText()) + try: + print( + "default>", + item.table_column_definition() + .constraint_common()[0] + .constr_body() + .default_expr.getText(), + ) + except Exception as e: + pass + # TODO fill self.__context + + +def parse_commands(content: str) -> Context: + LexerATNSimulator.debug = False + + result = Context() + lexer = PLpgSQLLexer(InputStream(content)) + stream = CommonTokenStream(lexer) + + parser = PLpgSQLParser(stream) + tree = parser.sql() + + listener = Listener(context=result) + walker = ParseTreeWalker() + walker.walk(listener, tree) + + return result diff --git a/tests/test_sql/test_schema_new.sql b/tests/test_sql/test_schema_new.sql new file mode 100644 index 0000000..045bf12 --- /dev/null +++ b/tests/test_sql/test_schema_new.sql @@ -0,0 +1,74 @@ +CREATE TYPE "process_state" AS ENUM ( + 'verification', + 'assessment', + 'processing' +); + +CREATE TYPE "issue_type" AS ENUM ( + 'could_not_verify', + 'segment_not_available', + 'priority_boarding_sold_out', + 'schedule_change', + 'invalid_pax_name', + 'price_change', + 'vpn_issues' +); + +CREATE TYPE "user_action_type" AS ENUM ( + 'send_email' +); + +CREATE TYPE "passenger_segment_state" AS ENUM ( + 'pending', + 'issue', + 'processed', + 'not_processed' +); + +CREATE TABLE "process" ( + "process_id" int PRIMARY KEY, + "booking_id" int, + "ticket_id" int, + "state" process_state, + "created_at" timestamp DEFAULT (now()), + "updated_at" timestamp +); + +CREATE TABLE "issue" ( + "issue_id" int PRIMARY KEY, + "process_id" int, + "type" issue_type, + "created_at" timestamp DEFAULT (now()) +); + +CREATE TABLE "user_action" ( + "email" varchar, + "type" user_action_type, + "issue_id" int, + "process_id" int, + "passenger_segment_id" int, + "created_at" timestamp DEFAULT (now()) +); + +CREATE TABLE "passenger_segment" ( + "passenger_segment_id" int PRIMARY KEY, + "process_id" int, + "passenger_id" int, + "segment_id" varchar, + "state" passenger_segment_state, + "issue_id" int, + "updated_at" timestamp, + "created_at" timestamp DEFAULT (now()) +); + +ALTER TABLE "issue" ADD FOREIGN KEY ("process_id") REFERENCES "process" ("process_id"); + +ALTER TABLE "user_action" ADD FOREIGN KEY ("issue_id") REFERENCES "issue" ("issue_id"); + +ALTER TABLE "user_action" ADD FOREIGN KEY ("process_id") REFERENCES "process" ("process_id"); + +ALTER TABLE "user_action" ADD FOREIGN KEY ("passenger_segment_id") REFERENCES "passenger_segment" ("passenger_segment_id"); + +ALTER TABLE "passenger_segment" ADD FOREIGN KEY ("process_id") REFERENCES "process" ("process_id"); + +ALTER TABLE "passenger_segment" ADD FOREIGN KEY ("issue_id") REFERENCES "issue" ("issue_id"); diff --git a/tests/unit/test_context_new.py b/tests/unit/test_context_new.py new file mode 100644 index 0000000..591fdf2 --- /dev/null +++ b/tests/unit/test_context_new.py @@ -0,0 +1,264 @@ +from sql_to_code.models import Context +from sql_to_code.parsers import Attribute, Enumeration, Reference, Table +from sql_to_code.parsers.generated import parse_commands +from sql_to_code.utils import get_file_content + +test_context = Context( + tables=[ + Table( + name="process", + schema=[ + Attribute( + name="process_id", + type="int", + is_default=False, + default=None, + primary_key=True, + nullable=False, + ), + Attribute( + name="booking_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="ticket_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="state", + type="process_state", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="created_at", + type="timestamp", + is_default=True, + default="", + primary_key=False, + nullable=True, + ), + Attribute( + name="updated_at", + type="timestamp", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + ], + ), + Table( + name="issue", + schema=[ + Attribute( + name="issue_id", + type="int", + is_default=False, + default=None, + primary_key=True, + nullable=False, + ), + Attribute( + name="process_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + foreign_key=Reference( + table_name="process", field_name="process_id" + ), + ), + Attribute( + name="type", + type="issue_type", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="created_at", + type="timestamp", + is_default=True, + default="", + primary_key=False, + nullable=True, + ), + ], + ), + Table( + name="user_action", + schema=[ + Attribute( + name="email", + type="varchar", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="type", + type="user_action_type", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="issue_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + foreign_key=Reference(table_name="issue", field_name="issue_id"), + ), + Attribute( + name="process_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + foreign_key=Reference( + table_name="process", field_name="process_id" + ), + ), + Attribute( + name="passenger_segment_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + foreign_key=Reference( + table_name="passenger_segment", + field_name="passenger_segment_id", + ), + ), + Attribute( + name="created_at", + type="timestamp", + is_default=True, + default="", + primary_key=False, + nullable=True, + ), + ], + ), + Table( + name="passenger_segment", + schema=[ + Attribute( + name="passenger_segment_id", + type="int", + is_default=False, + default=None, + primary_key=True, + nullable=False, + ), + Attribute( + name="process_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + foreign_key=Reference( + table_name="process", field_name="process_id", + ), + ), + Attribute( + name="passenger_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="segment_id", + type="varchar", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="state", + type="passenger_segment_state", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="issue_id", + type="int", + is_default=False, + default=None, + primary_key=False, + nullable=True, + foreign_key=Reference(table_name="issue", field_name="issue_id",), + ), + Attribute( + name="updated_at", + type="timestamp", + is_default=False, + default=None, + primary_key=False, + nullable=True, + ), + Attribute( + name="created_at", + type="timestamp", + is_default=True, + default="", + primary_key=False, + nullable=True, + ), + ], + ), + ], + enums=[ + Enumeration( + name="process_state", values=["verification", "assessment", "processing"] + ), + Enumeration( + name="issue_type", + values=[ + "could_not_verify", + "segment_not_available", + "priority_boarding_sold_out", + "schedule_change", + "invalid_pax_name", + "price_change", + "vpn_issues", + ], + ), + Enumeration(name="user_action_type", values=["send_email"]), + Enumeration( + name="passenger_segment_state", + values=["pending", "issue", "processed", "not_processed"], + ), + ], +) + + +def test_create_context() -> None: + sql_file = get_file_content("tests/test_sql/test_schema_new.sql") + context = parse_commands(sql_file) + assert context == test_context